@lexical/table 0.3.2 → 0.3.5

package/LexicalTable.dev.js

@@ -1385,14 +1385,14 @@ class TableNode extends lexical.GridNode {
 
   static importDOM() {
     return {
-      table: node => ({
+      table: _node => ({
         conversion: convertTableElement,
         priority: 0
       })
     };
   }
 
-  static importJSON(serializedNode) {
+  static importJSON(_serializedNode) {
     return $createTableNode();
   }
 
@@ -1557,7 +1557,7 @@ function $getElementGridForTableNode(editor, tableNode) {
 
   return getTableGrid(tableElement);
 }
-function convertTableElement(domNode) {
+function convertTableElement(_domNode) {
   return {
     node: $createTableNode()
   };

package/LexicalTableCellNode.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 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, NodeKey, SerializedGridCellNode, Spread } from 'lexical';
+import { GridCellNode } from 'lexical';
+export declare const TableCellHeaderStates: {
+    BOTH: number;
+    COLUMN: number;
+    NO_STATUS: number;
+    ROW: number;
+};
+export declare type TableCellHeaderState = typeof TableCellHeaderStates[keyof typeof TableCellHeaderStates];
+export declare type SerializedTableCellNode = Spread<{
+    headerState: TableCellHeaderState;
+    type: 'tablecell';
+    width: number;
+}, SerializedGridCellNode>;
+export declare class TableCellNode extends GridCellNode {
+    __headerState: TableCellHeaderState;
+    __width: number;
+    static getType(): 'tablecell';
+    static clone(node: TableCellNode): TableCellNode;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedTableCellNode): TableCellNode;
+    constructor(headerState?: number, colSpan?: number, width?: number, key?: NodeKey);
+    createDOM(config: EditorConfig): HTMLElement;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    exportJSON(): SerializedTableCellNode;
+    getTag(): string;
+    setHeaderStyles(headerState: TableCellHeaderState): TableCellHeaderState;
+    getHeaderStyles(): TableCellHeaderState;
+    setWidth(width: number): number;
+    getWidth(): number;
+    toggleHeaderStyle(headerStateToToggle: TableCellHeaderState): TableCellNode;
+    hasHeaderState(headerState: TableCellHeaderState): boolean;
+    hasHeader(): boolean;
+    updateDOM(prevNode: TableCellNode): 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/LexicalTableNode.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 { Cell, Grid } from './LexicalTableSelection';
+import type { DOMConversionMap, DOMConversionOutput, DOMExportOutput, EditorConfig, LexicalEditor, LexicalNode, NodeKey, SerializedElementNode, Spread } from 'lexical';
+import { GridNode } from 'lexical';
+export declare type SerializedTableNode = Spread<{
+    type: 'table';
+    version: 1;
+}, SerializedElementNode>;
+export declare class TableNode extends GridNode {
+    __grid: Grid;
+    static getType(): 'table';
+    static clone(node: TableNode): TableNode;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(_serializedNode: SerializedTableNode): TableNode;
+    constructor(key?: NodeKey);
+    exportJSON(): SerializedElementNode;
+    createDOM(config: EditorConfig, editor?: LexicalEditor): HTMLElement;
+    updateDOM(): boolean;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    canExtractContents(): false;
+    canBeEmpty(): false;
+    getCordsFromCellNode(tableCellNode: TableCellNode, grid: Grid): {
+        x: number;
+        y: number;
+    };
+    getCellFromCords(x: number, y: number, grid: Grid): Cell | null;
+    getCellFromCordsOrThrow(x: number, y: number, grid: Grid): Cell;
+    getCellNodeFromCords(x: number, y: number, grid: Grid): TableCellNode | null;
+    getCellNodeFromCordsOrThrow(x: number, y: number, grid: Grid): TableCellNode;
+    canSelectBefore(): true;
+    canIndent(): false;
+}
+export declare function $getElementGridForTableNode(editor: LexicalEditor, tableNode: TableNode): Grid;
+export declare function convertTableElement(_domNode: Node): DOMConversionOutput;
+export declare function $createTableNode(): TableNode;
+export declare function $isTableNode(node: LexicalNode | null | undefined): node is TableNode;

package/LexicalTableRowNode.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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 { Spread } from 'lexical';
+import { DOMConversionMap, DOMConversionOutput, EditorConfig, GridRowNode, LexicalNode, NodeKey, SerializedElementNode } from 'lexical';
+export declare type SerializedTableRowNode = Spread<{
+    height: number;
+    type: 'tablerow';
+    version: 1;
+}, SerializedElementNode>;
+export declare class TableRowNode extends GridRowNode {
+    __height: number;
+    static getType(): 'tablerow';
+    static clone(node: TableRowNode): TableRowNode;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedTableRowNode): TableRowNode;
+    constructor(height?: number, key?: NodeKey);
+    exportJSON(): SerializedElementNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    setHeight(height: number): number;
+    getHeight(): number;
+    updateDOM(prevNode: TableRowNode): 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,50 @@
+/**
+ * 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 { GridSelection, LexicalEditor, NodeKey, TextFormatType } from 'lexical';
+export declare type Cell = {
+    elem: HTMLElement;
+    highlighted: boolean;
+    x: number;
+    y: number;
+};
+export declare type Cells = Array<Array<Cell>>;
+export declare type Grid = {
+    cells: Cells;
+    columns: number;
+    rows: number;
+};
+export declare class TableSelection {
+    currentX: number;
+    currentY: number;
+    listenersToRemove: Set<() => void>;
+    domListeners: Set<() => void>;
+    grid: Grid;
+    isHighlightingCells: boolean;
+    startX: number;
+    startY: number;
+    tableNodeKey: NodeKey;
+    anchorCell: Cell | null;
+    focusCell: Cell | null;
+    anchorCellNodeKey: NodeKey | null;
+    focusCellNodeKey: NodeKey | null;
+    editor: LexicalEditor;
+    gridSelection: GridSelection | null;
+    hasHijackedSelectionStyles: boolean;
+    constructor(editor: LexicalEditor, tableNodeKey: string);
+    getGrid(): Grid;
+    removeListeners(): void;
+    trackTableGrid(): void;
+    clearHighlight(): void;
+    enableHighlightStyle(): void;
+    disableHighlightStyle(): void;
+    updateTableGridSelection(selection: GridSelection | null): void;
+    adjustFocusCellForSelection(cell: Cell, ignoreStart?: boolean): void;
+    setAnchorCellForSelection(cell: Cell): void;
+    formatCells(type: TextFormatType): void;
+    clearText(): void;
+}

package/LexicalTableSelectionHelpers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { TableNode } from './LexicalTableNode';
+import type { Cell, Grid } from './LexicalTableSelection';
+import type { GridSelection, LexicalEditor, LexicalNode, RangeSelection } from 'lexical';
+import { TableSelection } from './LexicalTableSelection';
+export declare function applyTableHandlers(tableNode: TableNode, tableElement: HTMLElement, editor: LexicalEditor): TableSelection;
+export declare function attachTableSelectionToTableElement(tableElement: HTMLElement, tableSelection: TableSelection): void;
+export declare function getTableSelectionFromTableElement(tableElement: HTMLElement): TableSelection;
+export declare function getCellFromTarget(node: Node): Cell | null;
+export declare function getTableGrid(tableElement: HTMLElement): Grid;
+export declare function $updateDOMForSelection(grid: Grid, selection: GridSelection | RangeSelection | null): Array<Cell>;
+export declare function $forEachGridCell(grid: Grid, cb: (cell: Cell, lexicalNode: LexicalNode, cords: {
+    x: number;
+    y: number;
+}) => void): void;
+export declare function $addHighlightStyleToTable(tableSelection: TableSelection): void;
+export declare function $removeHighlightStyleToTable(tableSelection: TableSelection): void;

package/LexicalTableUtils.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 type { Grid } from './LexicalTableSelection';
+import type { LexicalNode } from 'lexical';
+import { TableCellNode } from './LexicalTableCellNode';
+import { TableNode } from './LexicalTableNode';
+import { TableRowNode } from './LexicalTableRowNode';
+export declare function $createTableNodeWithDimensions(rowCount: number, columnCount: number, includeHeaders?: boolean): 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 declare type TableCellSiblings = {
+    above: TableCellNode | null | undefined;
+    below: TableCellNode | null | undefined;
+    left: TableCellNode | null | undefined;
+    right: TableCellNode | null | undefined;
+};
+export declare function $getTableCellSiblingsFromTableCellNode(tableCellNode: TableCellNode, grid: Grid): TableCellSiblings;
+export declare function $removeTableRowAtIndex(tableNode: TableNode, indexToDelete: number): TableNode;
+export declare function $insertTableRow(tableNode: TableNode, targetIndex: number, shouldInsertAfter: boolean, rowCount: number, grid: Grid): TableNode;
+export declare function $insertTableColumn(tableNode: TableNode, targetIndex: number, shouldInsertAfter: boolean, columnCount: number): TableNode;
+export declare function $deleteTableColumn(tableNode: TableNode, targetIndex: number): TableNode;

package/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 { Cell } from './LexicalTableSelection';
+import type { LexicalCommand } from 'lexical';
+import { $createTableCellNode, $isTableCellNode, TableCellHeaderStates, TableCellNode } from './LexicalTableCellNode';
+import { $createTableNode, $getElementGridForTableNode, $isTableNode, TableNode } from './LexicalTableNode';
+import { $createTableRowNode, $isTableRowNode, TableRowNode } from './LexicalTableRowNode';
+import { TableSelection } from './LexicalTableSelection';
+import { applyTableHandlers, getCellFromTarget, getTableSelectionFromTableElement } from './LexicalTableSelectionHelpers';
+import { $createTableNodeWithDimensions, $deleteTableColumn, $getTableCellNodeFromLexicalNode, $getTableColumnIndexFromTableCellNode, $getTableNodeFromLexicalNodeOrThrow, $getTableRowIndexFromTableCellNode, $getTableRowNodeFromTableCellNodeOrThrow, $insertTableColumn, $insertTableRow, $removeTableRowAtIndex } from './LexicalTableUtils';
+export { $createTableCellNode, $createTableNode, $createTableNodeWithDimensions, $createTableRowNode, $deleteTableColumn, $getElementGridForTableNode, $getTableCellNodeFromLexicalNode, $getTableColumnIndexFromTableCellNode, $getTableNodeFromLexicalNodeOrThrow, $getTableRowIndexFromTableCellNode, $getTableRowNodeFromTableCellNodeOrThrow, $insertTableColumn, $insertTableRow, $isTableCellNode, $isTableNode, $isTableRowNode, $removeTableRowAtIndex, applyTableHandlers, Cell, getCellFromTarget, getTableSelectionFromTableElement, TableCellHeaderStates, TableCellNode, TableNode, TableRowNode, TableSelection, };
+export declare type InsertTableCommandPayload = Readonly<{
+    columns: string;
+    rows: string;
+    includeHeaders?: boolean;
+}>;
+export declare const INSERT_TABLE_COMMAND: LexicalCommand<InsertTableCommandPayload>;

package/package.json

@@ -8,13 +8,13 @@
     "table"
   ],
   "license": "MIT",
-  "version": "0.3.2",
+  "version": "0.3.5",
   "main": "LexicalTable.js",
   "peerDependencies": {
-    "lexical": "0.3.2"
+    "lexical": "0.3.5"
   },
   "dependencies": {
-    "@lexical/utils": "0.3.2"
+    "@lexical/utils": "0.3.5"
   },
   "repository": {
     "type": "git",

package/utils.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 type { Grid } from './LexicalTableSelection';
+import type { LexicalNode } from 'lexical';
+import { TableCellNode } from './LexicalTableCellNode';
+import { TableNode } from './LexicalTableNode';
+import { TableRowNode } from './LexicalTableRowNode';
+export declare function $createTableNodeWithDimensions(rowCount: number, columnCount: number, includeHeaders?: boolean): 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 declare type TableCellSiblings = {
+    above: TableCellNode | null | undefined;
+    below: TableCellNode | null | undefined;
+    left: TableCellNode | null | undefined;
+    right: TableCellNode | null | undefined;
+};
+export declare function $getTableCellSiblingsFromTableCellNode(tableCellNode: TableCellNode, grid: Grid): TableCellSiblings;
+export declare function $removeTableRowAtIndex(tableNode: TableNode, indexToDelete: number): TableNode;
+export declare function $insertTableRow(tableNode: TableNode, targetIndex: number, shouldInsertAfter: boolean, rowCount: number, grid: Grid): TableNode;
+export declare function $insertTableColumn(tableNode: TableNode, targetIndex: number, shouldInsertAfter: boolean, columnCount: number): TableNode;
+export declare function $deleteTableColumn(tableNode: TableNode, targetIndex: number): TableNode;

package/LexicalTable.d.ts

@@ -1,229 +0,0 @@
-/**
- * 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 {
-  EditorConfig,
-  LexicalNode,
-  NodeKey,
-  ParagraphNode,
-  RangeSelection,
-  ElementNode,
-  LexicalEditor,
-  TextFormatType,
-  LexicalCommand,
-} from 'lexical';
-
-export enum TableCellHeaderStates {
-  NO_STATUS = 0,
-  ROW = 1,
-  COLUMN = 2,
-  BOTH = 3,
-}
-
-/**
- * LexicalTableCellNode
- */
-export declare class TableCellNode extends ElementNode {
-  static getType(): string;
-  static clone(node: TableCellNode): TableCellNode;
-  constructor(
-    headerState?: TableCellHeaderStates,
-    colSpan?: number,
-    width?: number | null | undefined,
-    key?: NodeKey,
-  );
-  __headerState: TableCellHeaderStates;
-  createDOM(config: EditorConfig): HTMLElement;
-  updateDOM(prevNode: TableCellNode, dom: HTMLElement): boolean;
-  insertNewAfter(
-    selection: RangeSelection,
-  ): null | ParagraphNode | TableCellNode;
-  collapseAtStart(): true;
-  getTag(): string;
-  setHeaderState(headerState: TableCellHeaderStates): TableCellHeaderStates;
-  getHeaderState(): TableCellHeaderStates;
-  toggleHeaderState(headerState: TableCellHeaderStates): TableCellNode;
-  hasHeader(): boolean;
-  setWidth(width: number): number | null | undefined;
-  getWidth(): number | null | undefined;
-  toggleHeaderStyle(headerState: TableCellHeaderStates): TableCellNode;
-  updateDOM(prevNode: TableCellNode): boolean;
-  collapseAtStart(): true;
-  canBeEmpty(): false;
-}
-declare function $createTableCellNode(
-  headerState: TableCellHeaderStates,
-  colSpan?: number,
-  width?: number | null | undefined,
-): TableCellNode;
-export declare function $isTableCellNode(
-  node?: LexicalNode,
-): node is TableCellNode;
-
-/**
- * LexicalTableNode
- */
-export declare class TableNode extends ElementNode {
-  static getType(): string;
-  static clone(node: TableNode): TableNode;
-  constructor(grid?: Grid, key?: NodeKey);
-  createDOM(config: EditorConfig): HTMLElement;
-  updateDOM(prevNode: TableNode, dom: HTMLElement): boolean;
-  insertNewAfter(selection: RangeSelection): null | ParagraphNode | TableNode;
-  collapseAtStart(): true;
-  getCordsFromCellNode(tableCellNode: TableCellNode): {x: number; y: number};
-  getCellFromCords(x: number, y: number, grid: Grid): Cell | null | undefined;
-  getCellFromCordsOrThrow(x: number, y: number, grid: Grid): Cell;
-  getCellNodeFromCords(x: number, y: number): TableCellNode | null;
-  getCellNodeFromCordsOrThrow(x: number, y: number): TableCellNode;
-  setGrid(grid?: Grid): TableNode;
-  getGrid(): Grid | null;
-  canSelectBefore(): true;
-}
-declare function $createTableNode(): TableNode;
-declare function $isTableNode(node?: LexicalNode): node is TableNode;
-
-/**
- * LexicalTableRowNode
- */
-
-declare class TableRowNode extends ElementNode {
-  static getType(): string;
-  static clone(node: TableRowNode): TableRowNode;
-  constructor(key?: NodeKey, height?: number | null | undefined);
-  createDOM(config: EditorConfig): HTMLElement;
-  updateDOM(prevNode: TableRowNode, dom: HTMLElement): boolean;
-  insertNewAfter(
-    selection: RangeSelection,
-  ): null | ParagraphNode | TableRowNode;
-  setHeight(height: number): number | null | undefined;
-  getHeight(): number | null | undefined;
-  collapseAtStart(): true;
-}
-declare function $createTableRowNode(): TableRowNode;
-declare function $isTableRowNode(node?: LexicalNode): node is TableRowNode;
-
-/**
- * LexicalTableSelectionHelpers
- */
-export type Cell = {
-  elem: HTMLElement;
-  highlighted: boolean;
-  x: number;
-  y: number;
-};
-export type Cells = Array<Array<Cell>>;
-export type Grid = {
-  cells: Cells;
-  columns: number;
-  rows: number;
-};
-
-declare function applyTableHandlers(
-  tableNode: TableNode,
-  tableElement: HTMLElement,
-  editor: LexicalEditor,
-): TableSelection;
-
-declare function $getElementGridForTableNode(
-  editor: LexicalEditor,
-  tableNode: TableNode,
-): Grid;
-
-declare function getTableSelectionFromTableElement(
-  tableElement: HTMLElement,
-): TableSelection;
-
-declare function getCellFromTarget(node: Node): Cell | null;
-
-/**
- * LexicalTableUtils
- */
-
-declare function $createTableNodeWithDimensions(
-  rowCount: number,
-  columnCount: number,
-  includeHeaders?: boolean,
-): TableNode;
-
-declare function $getTableCellNodeFromLexicalNode(
-  startingNode: LexicalNode,
-): TableCellNode | null;
-
-declare function $getTableRowNodeFromTableCellNodeOrThrow(
-  startingNode: LexicalNode,
-): TableRowNode;
-
-declare function $getTableNodeFromLexicalNodeOrThrow(
-  startingNode: LexicalNode,
-): TableNode;
-
-declare function $getTableRowIndexFromTableCellNode(
-  tableCellNode: TableCellNode,
-): number;
-
-declare function $getTableColumnIndexFromTableCellNode(
-  tableCellNode: TableCellNode,
-): number;
-
-declare function $removeTableRowAtIndex(
-  tableNode: TableNode,
-  indexToDelete: number,
-): TableNode;
-
-declare function $insertTableRow(
-  tableNode: TableNode,
-  targetIndex: number,
-  shouldInsertAfter: boolean,
-  rowCount: number,
-  grid: Grid,
-): TableNode;
-
-declare function $insertTableColumn(
-  tableNode: TableNode,
-  targetIndex: number,
-  shouldInsertAfter: boolean,
-  columnCount: number,
-): TableNode;
-
-declare function $deleteTableColumn(
-  tableNode: TableNode,
-  targetIndex: number,
-): TableNode;
-
-/**
- * LexicalTableSelection.js
- */
-export declare class TableSelection {
-  currentX: number;
-  currentY: number;
-  listenersToRemove: Set<() => void>;
-  domListeners: Set<() => void>;
-  grid: Grid;
-  isHighlightingCells: boolean;
-  isMouseDown: boolean;
-  startX: number;
-  startY: number;
-  nodeKey: string;
-  editor: LexicalEditor;
-  constructor(editor: LexicalEditor, nodeKey: string);
-  getGrid(): Grid;
-  removeListeners(): void;
-  trackTableGrid(): void;
-  clearHighlight(): void;
-  adjustFocusCellForSelection(cell: Cell): void;
-  setAnchorCellForSelection(cell: Cell): void;
-  formatCells(type: TextFormatType): void;
-  clearText(): void;
-}
-export type InsertTableCommandPayload = Readonly<{
-  columns: string;
-  rows: string;
-  includeHeaders?: boolean;
-}>;
-export const INSERT_TABLE_COMMAND: LexicalCommand<InsertTableCommandPayload>;