@ekz/lexical-table 0.40.0

package/LexicalTableObserver.d.ts

@@ -0,0 +1,109 @@
+/**
+ * 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 { LexicalEditor, NodeKey, TextFormatType } from '@ekz/lexical';
+import { TableCellNode } from './LexicalTableCellNode';
+import { TableNode } from './LexicalTableNode';
+import { type TableSelection } from './LexicalTableSelection';
+import { HTMLTableElementWithWithTableSelectionState } from './LexicalTableSelectionHelpers';
+export type TableDOMCell = {
+    elem: HTMLElement;
+    highlighted: boolean;
+    hasBackgroundColor: boolean;
+    x: number;
+    y: number;
+};
+export type TableDOMRows = Array<Array<TableDOMCell | undefined> | undefined>;
+export type TableDOMTable = {
+    domRows: TableDOMRows;
+    columns: number;
+    rows: number;
+};
+export declare function $getTableAndElementByKey(tableNodeKey: NodeKey, editor?: LexicalEditor): {
+    tableNode: TableNode;
+    tableElement: HTMLTableElementWithWithTableSelectionState;
+};
+export declare class TableObserver {
+    focusX: number;
+    focusY: number;
+    listenersToRemove: Set<() => void>;
+    table: TableDOMTable;
+    isHighlightingCells: boolean;
+    anchorX: number;
+    anchorY: number;
+    tableNodeKey: NodeKey;
+    anchorCell: TableDOMCell | null;
+    focusCell: TableDOMCell | null;
+    anchorCellNodeKey: NodeKey | null;
+    focusCellNodeKey: NodeKey | null;
+    editor: LexicalEditor;
+    tableSelection: TableSelection | null;
+    hasHijackedSelectionStyles: boolean;
+    isSelecting: boolean;
+    pointerType: string | null;
+    shouldCheckSelection: boolean;
+    abortController: AbortController;
+    listenerOptions: {
+        signal: AbortSignal;
+    };
+    nextFocus: {
+        focusCell: TableDOMCell;
+        override: boolean;
+    } | null;
+    constructor(editor: LexicalEditor, tableNodeKey: string);
+    getTable(): TableDOMTable;
+    removeListeners(): void;
+    $lookup(): {
+        tableNode: TableNode;
+        tableElement: HTMLTableElementWithWithTableSelectionState;
+    };
+    trackTable(): void;
+    $clearHighlight(): void;
+    $enableHighlightStyle(): void;
+    $disableHighlightStyle(): void;
+    $updateTableTableSelection(selection: TableSelection | null): void;
+    /**
+     * @internal
+     * Firefox has a strange behavior where pressing the down arrow key from
+     * above the table will move the caret after the table and then lexical
+     * will select the last cell instead of the first.
+     * We do still want to let the browser handle caret movement but we will
+     * use this property to "tag" the update so that we can recheck the
+     * selection after the event is processed.
+     */
+    setShouldCheckSelection(): void;
+    /**
+     * @internal
+     */
+    getAndClearShouldCheckSelection(): boolean;
+    /**
+     * @internal
+     * When handling mousemove events we track what the focus cell should be, but
+     * the DOM selection may end up somewhere else entirely. We don't have an elegant
+     * way to handle this after the DOM selection has been resolved in a
+     * SELECTION_CHANGE_COMMAND callback.
+     */
+    setNextFocus(nextFocus: null | {
+        focusCell: TableDOMCell;
+        override: boolean;
+    }): void;
+    /** @internal */
+    getAndClearNextFocus(): {
+        focusCell: TableDOMCell;
+        override: boolean;
+    } | null;
+    /** @internal */
+    updateDOMSelection(): void;
+    $setFocusCellForSelection(cell: TableDOMCell, ignoreStart?: boolean): boolean;
+    $getAnchorTableCell(): TableCellNode | null;
+    $getAnchorTableCellOrThrow(): TableCellNode;
+    $getFocusTableCell(): TableCellNode | null;
+    $getFocusTableCellOrThrow(): TableCellNode;
+    $setAnchorCellForSelection(cell: TableDOMCell): void;
+    $formatCells(type: TextFormatType): void;
+    $clearText(): void;
+}

package/LexicalTablePluginHelpers.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { Signal } from '@ekz/lexical-extension';
+import { LexicalEditor } from '@ekz/lexical';
+/**
+ * Register a transform to ensure that all TableCellNode have a colSpan and rowSpan of 1.
+ * This should only be registered when you do not want to support merged cells.
+ *
+ * @param editor The editor
+ * @returns An unregister callback
+ */
+export declare function registerTableCellUnmergeTransform(editor: LexicalEditor): () => void;
+export declare function registerTableSelectionObserver(editor: LexicalEditor, hasTabHandler?: boolean): () => void;
+/**
+ * Register the INSERT_TABLE_COMMAND listener and the table integrity transforms. The
+ * table selection observer should be registered separately after this with
+ * {@link registerTableSelectionObserver}.
+ *
+ * @param editor The editor
+ * @returns An unregister callback
+ */
+export declare function registerTablePlugin(editor: LexicalEditor, options?: {
+    hasNestedTables?: Signal<boolean>;
+}): () => void;

package/LexicalTableRowNode.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 { BaseSelection, LexicalUpdateJSON, Spread } from '@ekz/lexical';
+import { DOMConversionMap, DOMConversionOutput, EditorConfig, ElementNode, LexicalNode, NodeKey, SerializedElementNode } from '@ekz/lexical';
+export type SerializedTableRowNode = Spread<{
+    height?: number;
+}, SerializedElementNode>;
+/** @noInheritDoc */
+export declare class TableRowNode extends ElementNode {
+    /** @internal */
+    __height?: number;
+    static getType(): string;
+    static clone(node: TableRowNode): TableRowNode;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedTableRowNode): TableRowNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedTableRowNode>): this;
+    constructor(height?: number, key?: NodeKey);
+    exportJSON(): SerializedTableRowNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    extractWithChild(child: LexicalNode, selection: BaseSelection | null, destination: 'clone' | 'html'): boolean;
+    isShadowRoot(): boolean;
+    setHeight(height?: number | undefined): this;
+    getHeight(): number | undefined;
+    updateDOM(prevNode: this): boolean;
+    canBeEmpty(): false;
+    canIndent(): false;
+}
+export declare function $convertTableRowElement(domNode: Node): DOMConversionOutput;
+export declare function $createTableRowNode(height?: number): TableRowNode;
+export declare function $isTableRowNode(node: LexicalNode | null | undefined): node is TableRowNode;

package/LexicalTableSelection.d.ts

@@ -0,0 +1,75 @@
+/**
+ * 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, LexicalNode, NodeKey, PointType, TextFormatType } from '@ekz/lexical';
+import { TableCellNode } from './LexicalTableCellNode';
+import { TableNode } from './LexicalTableNode';
+export type TableSelectionShape = {
+    fromX: number;
+    fromY: number;
+    toX: number;
+    toY: number;
+};
+export type TableMapValueType = {
+    cell: TableCellNode;
+    startRow: number;
+    startColumn: number;
+};
+export type TableMapType = Array<Array<TableMapValueType>>;
+export declare class TableSelection implements BaseSelection {
+    tableKey: NodeKey;
+    anchor: PointType;
+    focus: PointType;
+    _cachedNodes: Array<LexicalNode> | null;
+    dirty: boolean;
+    constructor(tableKey: NodeKey, anchor: PointType, focus: PointType);
+    getStartEndPoints(): [PointType, PointType];
+    /**
+     * {@link $createTableSelection} unfortunately makes it very easy to create
+     * nonsense selections, so we have a method to see if the selection probably
+     * makes sense.
+     *
+     * @returns true if the TableSelection is (probably) valid
+     */
+    isValid(): boolean;
+    /**
+     * Returns whether the Selection is "backwards", meaning the focus
+     * logically precedes the anchor in the EditorState.
+     * @returns true if the Selection is backwards, false otherwise.
+     */
+    isBackward(): boolean;
+    getCachedNodes(): LexicalNode[] | null;
+    setCachedNodes(nodes: LexicalNode[] | null): void;
+    is(selection: null | BaseSelection): boolean;
+    set(tableKey: NodeKey, anchorCellKey: NodeKey, focusCellKey: NodeKey): void;
+    clone(): TableSelection;
+    isCollapsed(): boolean;
+    extract(): Array<LexicalNode>;
+    insertRawText(text: string): void;
+    insertText(): void;
+    /**
+     * Returns whether the provided TextFormatType is present on the Selection.
+     * This will be true if any paragraph in table cells has the specified format.
+     *
+     * @param type the TextFormatType to check for.
+     * @returns true if the provided format is currently toggled on on the Selection, false otherwise.
+     */
+    hasFormat(type: TextFormatType): boolean;
+    insertNodes(nodes: Array<LexicalNode>): void;
+    getShape(): TableSelectionShape;
+    getNodes(): Array<LexicalNode>;
+    getTextContent(): string;
+}
+export declare function $isTableSelection(x: unknown): x is TableSelection;
+export declare function $createTableSelection(): TableSelection;
+export declare function $createTableSelectionFrom(tableNode: TableNode, anchorCell: TableCellNode, focusCell: TableCellNode): TableSelection;
+/**
+ * Depth first visitor
+ * @param node The starting node
+ * @param $visit The function to call for each node. If the function returns false, then children of this node will not be explored
+ */
+export declare function $visitRecursively(node: LexicalNode, $visit: (childNode: LexicalNode) => boolean | undefined | void): void;

package/LexicalTableSelectionHelpers.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { TableCellNode } from './LexicalTableCellNode';
+import type { TableDOMCell } from './LexicalTableObserver';
+import type { TableSelection } from './LexicalTableSelection';
+import type { EditorState, LexicalEditor, LexicalNode, RangeSelection } from '@ekz/lexical';
+import { TableNode } from './LexicalTableNode';
+import { TableDOMTable, TableObserver } from './LexicalTableObserver';
+declare const LEXICAL_ELEMENT_KEY = "__lexicalTableSelection";
+export declare function isHTMLTableElement(el: unknown): el is HTMLTableElement;
+export declare function getTableElement<T extends HTMLElement | null>(tableNode: TableNode, dom: T): HTMLTableElementWithWithTableSelectionState | (T & null);
+export declare function getEditorWindow(editor: LexicalEditor): Window | null;
+export declare function $findParentTableCellNodeInTable(tableNode: LexicalNode, node: LexicalNode | null): TableCellNode | null;
+export declare function applyTableHandlers(tableNode: TableNode, element: HTMLElement, editor: LexicalEditor, hasTabHandler: boolean): TableObserver;
+export type HTMLTableElementWithWithTableSelectionState = HTMLTableElement & {
+    [LEXICAL_ELEMENT_KEY]?: TableObserver | undefined;
+};
+export declare function detachTableObserverFromTableElement(tableElement: HTMLTableElementWithWithTableSelectionState, tableObserver: TableObserver): void;
+export declare function attachTableObserverToTableElement(tableElement: HTMLTableElementWithWithTableSelectionState, tableObserver: TableObserver): void;
+export declare function getTableObserverFromTableElement(tableElement: HTMLTableElementWithWithTableSelectionState): TableObserver | null;
+export declare function getDOMCellFromTarget(node: null | Node): TableDOMCell | null;
+export declare function getDOMCellInTableFromTarget(table: HTMLTableElementWithWithTableSelectionState, node: null | Node): TableDOMCell | null;
+export declare function doesTargetContainText(node: Node): boolean;
+export declare function getTable(tableNode: TableNode, dom: HTMLElement): TableDOMTable;
+export declare function $updateDOMForSelection(editor: LexicalEditor, table: TableDOMTable, selection: TableSelection | RangeSelection | null): void;
+export declare function $forEachTableCell(grid: TableDOMTable, cb: (cell: TableDOMCell, lexicalNode: LexicalNode, cords: {
+    x: number;
+    y: number;
+}) => void): void;
+export declare function $addHighlightStyleToTable(editor: LexicalEditor, tableSelection: TableObserver): void;
+export declare function $removeHighlightStyleToTable(editor: LexicalEditor, tableObserver: TableObserver): void;
+export declare function $findCellNode(node: LexicalNode): null | TableCellNode;
+export declare function $findTableNode(node: LexicalNode): null | TableNode;
+export declare function $getObserverCellFromCellNodeOrThrow(tableObserver: TableObserver, tableCellNode: TableCellNode): TableDOMCell;
+export declare function $getNearestTableCellInTableFromDOMNode(tableNode: TableNode, startingDOM: Node, editorState?: EditorState): TableCellNode | null;
+export {};

package/LexicalTableUtils.d.ts

@@ -0,0 +1,113 @@
+/**
+ * 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 { TableMapType, TableMapValueType } from './LexicalTableSelection';
+import type { PointType } from '@ekz/lexical';
+import { LexicalNode } from '@ekz/lexical';
+import { InsertTableCommandPayloadHeaders } from '.';
+import { TableCellNode } from './LexicalTableCellNode';
+import { TableNode } from './LexicalTableNode';
+import { TableDOMTable } from './LexicalTableObserver';
+import { TableRowNode } from './LexicalTableRowNode';
+export declare function $createTableNodeWithDimensions(rowCount: number, columnCount: number, includeHeaders?: InsertTableCommandPayloadHeaders): TableNode;
+export declare function $getTableCellNodeFromLexicalNode(startingNode: LexicalNode): TableCellNode | null;
+export declare function $getTableRowNodeFromTableCellNodeOrThrow(startingNode: LexicalNode): TableRowNode;
+export declare function $getTableNodeFromLexicalNodeOrThrow(startingNode: LexicalNode): TableNode;
+export declare function $getTableRowIndexFromTableCellNode(tableCellNode: TableCellNode): number;
+export declare function $getTableColumnIndexFromTableCellNode(tableCellNode: TableCellNode): number;
+export type TableCellSiblings = {
+    above: TableCellNode | null | undefined;
+    below: TableCellNode | null | undefined;
+    left: TableCellNode | null | undefined;
+    right: TableCellNode | null | undefined;
+};
+export declare function $getTableCellSiblingsFromTableCellNode(tableCellNode: TableCellNode, table: TableDOMTable): TableCellSiblings;
+export declare function $removeTableRowAtIndex(tableNode: TableNode, indexToDelete: number): TableNode;
+/**
+ * @deprecated This function does not support merged cells. Use {@link $insertTableRowAtSelection} or {@link $insertTableRowAtNode} instead.
+ */
+export declare function $insertTableRow(tableNode: TableNode, targetIndex: number, shouldInsertAfter: boolean | undefined, rowCount: number, table: TableDOMTable): TableNode;
+/**
+ * Inserts a table row before or after the current focus cell node,
+ * taking into account any spans. If successful, returns the
+ * inserted table row node.
+ */
+export declare function $insertTableRowAtSelection(insertAfter?: boolean): TableRowNode | null;
+/**
+ * @deprecated renamed to {@link $insertTableRowAtSelection}
+ */
+export declare const $insertTableRow__EXPERIMENTAL: typeof $insertTableRowAtSelection;
+/**
+ * Inserts a table row before or after the given cell node,
+ * taking into account any spans. If successful, returns the
+ * inserted table row node.
+ */
+export declare function $insertTableRowAtNode(cellNode: TableCellNode, insertAfter?: boolean): TableRowNode | null;
+/**
+ * @deprecated This function does not support merged cells. Use {@link $insertTableColumnAtSelection} or {@link $insertTableColumnAtNode} instead.
+ */
+export declare function $insertTableColumn(tableNode: TableNode, targetIndex: number, shouldInsertAfter: boolean | undefined, columnCount: number, table: TableDOMTable): TableNode;
+/**
+ * Inserts a column before or after the current focus cell node,
+ * taking into account any spans. If successful, returns the
+ * first inserted cell node.
+ */
+export declare function $insertTableColumnAtSelection(insertAfter?: boolean): TableCellNode | null;
+/**
+ * @deprecated renamed to {@link $insertTableColumnAtSelection}
+ */
+export declare const $insertTableColumn__EXPERIMENTAL: typeof $insertTableColumnAtSelection;
+/**
+ * Inserts a column before or after the given cell node,
+ * taking into account any spans. If successful, returns the
+ * first inserted cell node.
+ */
+export declare function $insertTableColumnAtNode(cellNode: TableCellNode, insertAfter?: boolean, shouldSetSelection?: boolean): TableCellNode | null;
+/**
+ * @deprecated This function does not support merged cells. Use {@link $deleteTableColumnAtSelection} instead.
+ */
+export declare function $deleteTableColumn(tableNode: TableNode, targetIndex: number): TableNode;
+export declare function $deleteTableRowAtSelection(): void;
+/**
+ * @deprecated renamed to {@link $deleteTableRowAtSelection}
+ */
+export declare const $deleteTableRow__EXPERIMENTAL: typeof $deleteTableRowAtSelection;
+export declare function $deleteTableColumnAtSelection(): void;
+/**
+ * @deprecated renamed to {@link $deleteTableColumnAtSelection}
+ */
+export declare const $deleteTableColumn__EXPERIMENTAL: typeof $deleteTableColumnAtSelection;
+export declare function $mergeCells(cellNodes: TableCellNode[]): TableCellNode | null;
+export declare function $unmergeCell(): void;
+export declare function $unmergeCellNode(cellNode: TableCellNode): void;
+export declare function $computeTableMap(tableNode: TableNode, cellA: TableCellNode, cellB: TableCellNode): [TableMapType, TableMapValueType, TableMapValueType];
+export declare function $computeTableMapSkipCellCheck(tableNode: TableNode, cellA: null | TableCellNode, cellB: null | TableCellNode): [
+    tableMap: TableMapType,
+    cellAValue: TableMapValueType | null,
+    cellBValue: TableMapValueType | null
+];
+export declare function $getNodeTriplet(source: PointType | LexicalNode | TableCellNode): [TableCellNode, TableRowNode, TableNode];
+export interface TableCellRectBoundary {
+    minColumn: number;
+    minRow: number;
+    maxColumn: number;
+    maxRow: number;
+}
+export interface TableCellRectSpans {
+    topSpan: number;
+    leftSpan: number;
+    rightSpan: number;
+    bottomSpan: number;
+}
+export declare function $computeTableCellRectSpans(map: TableMapType, boundary: TableCellRectBoundary): TableCellRectSpans;
+export declare function $computeTableCellRectBoundary(map: TableMapType, cellAMap: TableMapValueType, cellBMap: TableMapValueType): TableCellRectBoundary;
+export declare function $getTableCellNodeRect(tableCellNode: TableCellNode): {
+    rowIndex: number;
+    columnIndex: number;
+    rowSpan: number;
+    colSpan: number;
+} | null;

package/README.md

@@ -0,0 +1,52 @@
+# `@lexical/table`
+
+[![See API Documentation](https://lexical.dev/img/see-api-documentation.svg)](https://lexical.dev/docs/api/modules/lexical_table)
+
+This package contains the functionality for the Tables feature of Lexical.
+
+# Lexical Table Plugin
+
+A plugin for handling tables in Lexical.
+
+## Installation
+
+```bash
+npm install @lexical/table @lexical/react
+```
+
+## Usage
+
+See the [react-table example](https://github.com/facebook/lexical/tree/main/examples/react-table)
+for a minimal example that uses this package and the
+[TablePlugin](https://lexical.dev/docs/api/modules/lexical_react_LexicalTablePlugin)
+from @lexical/react/LexicalTablePlugin
+
+[![Open in StackBlitz](https://developer.stackblitz.com/img/open_in_stackblitz.svg)](https://stackblitz.com/github/facebook/lexical/tree/main/examples/react-table?file=src/main.tsx)
+
+## Features
+
+### Tables
+- Create and edit tables with customizable rows and columns
+- Support for table headers
+- Cell selection and navigation
+- Copy and paste support
+
+### Limitations
+
+#### Nested Tables
+Nested tables (tables within table cells) are not supported in the editor. The following behaviors are enforced:
+
+1. When attempting to paste a table inside an existing table cell, the paste operation is blocked.
+2. The editor actively prevents the creation of nested tables through the UI or programmatically.
+
+Note: When pasting HTML content with nested tables, the nested content will be removed by default. Make sure to implement appropriate `importDOM` handling if you need to preserve this content in some form.
+
+This approach allows you to:
+1. Detect nested tables in the imported HTML
+2. Extract their content before it gets removed
+3. Preserve the content in a format that works for your use case
+
+Choose an approach that best fits your needs:
+- Flatten nested tables into a single table
+- Convert nested tables to a different format (e.g., lists or paragraphs)
+- Store nested content as metadata for future processing

package/constants.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 declare const PIXEL_VALUE_REG_EXP: RegExp;
+export declare const COLUMN_WIDTH = 75;

package/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 type { SerializedTableCellNode } from './LexicalTableCellNode';
+export { $createTableCellNode, $isTableCellNode, TableCellHeaderStates, TableCellNode, } from './LexicalTableCellNode';
+export type { InsertTableCommandPayload, InsertTableCommandPayloadHeaders, } from './LexicalTableCommands';
+export { INSERT_TABLE_COMMAND } from './LexicalTableCommands';
+export { type TableConfig, TableExtension } from './LexicalTableExtension';
+export type { SerializedTableNode } from './LexicalTableNode';
+export { $createTableNode, $getElementForTableNode, $isScrollableTablesActive, $isTableNode, setScrollableTablesActive, TableNode, } from './LexicalTableNode';
+export type { TableDOMCell } from './LexicalTableObserver';
+export { $getTableAndElementByKey, TableObserver } from './LexicalTableObserver';
+export { registerTableCellUnmergeTransform, registerTablePlugin, registerTableSelectionObserver, } from './LexicalTablePluginHelpers';
+export type { SerializedTableRowNode } from './LexicalTableRowNode';
+export { $createTableRowNode, $isTableRowNode, TableRowNode, } from './LexicalTableRowNode';
+export type { TableMapType, TableMapValueType, TableSelection, TableSelectionShape, } from './LexicalTableSelection';
+export { $createTableSelection, $createTableSelectionFrom, $isTableSelection, } from './LexicalTableSelection';
+export type { HTMLTableElementWithWithTableSelectionState } from './LexicalTableSelectionHelpers';
+export { $findCellNode, $findTableNode, applyTableHandlers, getDOMCellFromTarget, getTableElement, getTableObserverFromTableElement, } from './LexicalTableSelectionHelpers';
+export { $computeTableMap, $computeTableMapSkipCellCheck, $createTableNodeWithDimensions, $deleteTableColumn, $deleteTableColumn__EXPERIMENTAL, $deleteTableColumnAtSelection, $deleteTableRow__EXPERIMENTAL, $deleteTableRowAtSelection, $getNodeTriplet, $getTableCellNodeFromLexicalNode, $getTableCellNodeRect, $getTableColumnIndexFromTableCellNode, $getTableNodeFromLexicalNodeOrThrow, $getTableRowIndexFromTableCellNode, $getTableRowNodeFromTableCellNodeOrThrow, $insertTableColumn, $insertTableColumn__EXPERIMENTAL, $insertTableColumnAtSelection, $insertTableRow, $insertTableRow__EXPERIMENTAL, $insertTableRowAtSelection, $mergeCells, $removeTableRowAtIndex, $unmergeCell, } from './LexicalTableUtils';

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@ekz/lexical-table",
+  "description": "This package provides the Table feature for Lexical.",
+  "keywords": [
+    "lexical",
+    "editor",
+    "rich-text",
+    "table"
+  ],
+  "license": "MIT",
+  "version": "0.40.0",
+  "main": "LexicalTable.js",
+  "types": "index.d.ts",
+  "dependencies": {
+    "@ekz/lexical-clipboard": "0.40.0",
+    "@ekz/lexical-extension": "0.40.0",
+    "@ekz/lexical-utils": "0.40.0",
+    "@ekz/lexical": "0.40.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/facebook/lexical.git",
+    "directory": "packages/lexical-table"
+  },
+  "module": "LexicalTable.mjs",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "development": "./LexicalTable.dev.mjs",
+        "production": "./LexicalTable.prod.mjs",
+        "node": "./LexicalTable.node.mjs",
+        "default": "./LexicalTable.mjs"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "development": "./LexicalTable.dev.js",
+        "production": "./LexicalTable.prod.js",
+        "default": "./LexicalTable.js"
+      }
+    }
+  }
+}