@atlaskit/editor-plugin-table 0.0.0 → 0.0.2

package/src/plugins/table/utils/decoration.ts

@@ -0,0 +1,456 @@
+import { Node as PmNode } from 'prosemirror-model';
+import { Selection, Transaction, ReadonlyTransaction } from 'prosemirror-state';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { ContentNodeWithPos } from 'prosemirror-utils';
+import {
+  findTable,
+  getCellsInRow,
+  getSelectionRect,
+} from '@atlaskit/editor-tables/utils';
+
+import { Decoration, DecorationSet } from 'prosemirror-view';
+
+import { CellAttributes } from '@atlaskit/adf-schema';
+
+// import { nonNullable } from '@atlaskit/editor-core/src/utils';
+import { nonNullable } from '@atlaskit/editor-common/utils';
+import {
+  Cell,
+  CellColumnPositioning,
+  TableCssClassName as ClassName,
+  TableDecorations,
+} from '../types';
+
+const filterDecorationByKey = (
+  key: TableDecorations,
+  decorationSet: DecorationSet,
+): Decoration[] =>
+  decorationSet.find(
+    undefined,
+    undefined,
+    (spec) => spec.key.indexOf(key) > -1,
+  );
+
+export const findColumnControlSelectedDecoration = (
+  decorationSet: DecorationSet,
+): Decoration[] =>
+  filterDecorationByKey(TableDecorations.COLUMN_SELECTED, decorationSet);
+
+export const findControlsHoverDecoration = (
+  decorationSet: DecorationSet,
+): Decoration[] =>
+  filterDecorationByKey(TableDecorations.ALL_CONTROLS_HOVER, decorationSet);
+
+export const createCellHoverDecoration = (
+  cells: Cell[],
+  type: 'warning',
+): Decoration[] =>
+  cells.map((cell) =>
+    Decoration.node(
+      cell.pos,
+      cell.pos + cell.node.nodeSize,
+      {
+        class: ClassName.HOVERED_CELL_WARNING,
+      },
+      {
+        key: TableDecorations.CELL_CONTROLS_HOVER,
+      },
+    ),
+  );
+
+export const createControlsHoverDecoration = (
+  cells: Cell[],
+  type: 'row' | 'column' | 'table',
+  danger?: boolean,
+  selected?: boolean,
+): Decoration[] =>
+  cells.map((cell) => {
+    const classes = [ClassName.HOVERED_CELL];
+    if (danger) {
+      classes.push(ClassName.HOVERED_CELL_IN_DANGER);
+    }
+    if (selected) {
+      classes.push(ClassName.SELECTED_CELL);
+    }
+
+    classes.push(
+      type === 'column'
+        ? ClassName.HOVERED_COLUMN
+        : type === 'row'
+        ? ClassName.HOVERED_ROW
+        : ClassName.HOVERED_TABLE,
+    );
+
+    let key: TableDecorations;
+    switch (type) {
+      case 'row':
+        key = TableDecorations.ROW_CONTROLS_HOVER;
+        break;
+
+      case 'column':
+        key = TableDecorations.COLUMN_CONTROLS_HOVER;
+        break;
+
+      default:
+        key = TableDecorations.TABLE_CONTROLS_HOVER;
+        break;
+    }
+
+    return Decoration.node(
+      cell.pos,
+      cell.pos + cell.node.nodeSize,
+      {
+        class: classes.join(' '),
+      },
+      { key },
+    );
+  });
+
+export const createColumnSelectedDecoration = (
+  tr: Transaction | ReadonlyTransaction,
+): Decoration[] => {
+  const { selection, doc } = tr;
+  const table = findTable(selection);
+  const rect = getSelectionRect(selection);
+
+  if (!table || !rect) {
+    return [];
+  }
+
+  const map = TableMap.get(table.node);
+  const cellPositions = map.cellsInRect(rect);
+
+  return cellPositions.map((pos, index) => {
+    const cell = doc.nodeAt(pos + table.start);
+
+    return Decoration.node(
+      pos + table.start,
+      pos + table.start + cell!.nodeSize,
+      {
+        class: ClassName.COLUMN_SELECTED,
+      },
+      {
+        key: `${TableDecorations.COLUMN_SELECTED}_${index}`,
+      },
+    );
+  });
+};
+
+export const createColumnControlsDecoration = (
+  selection: Selection,
+): Decoration[] => {
+  const cells: ContentNodeWithPos[] = getCellsInRow(0)(selection) || [];
+  let index = 0;
+  return cells.map((cell) => {
+    const colspan = (cell.node.attrs as CellAttributes).colspan || 1;
+    const element = document.createElement('div');
+    element.classList.add(ClassName.COLUMN_CONTROLS_DECORATIONS);
+    element.dataset.startIndex = `${index}`;
+    index += colspan;
+    element.dataset.endIndex = `${index}`;
+
+    return Decoration.widget(cell.pos + 1, () => element, {
+      key: `${TableDecorations.COLUMN_CONTROLS_DECORATIONS}_${index}`,
+      // this decoration should be the first one, even before gap cursor.
+      side: -100,
+    });
+  });
+};
+
+export const updateDecorations = (
+  node: PmNode,
+  decorationSet: DecorationSet,
+  decorations: Decoration[],
+  key: TableDecorations,
+): DecorationSet => {
+  const filteredDecorations = filterDecorationByKey(key, decorationSet);
+  const decorationSetFiltered = decorationSet.remove(filteredDecorations);
+
+  return decorationSetFiltered.add(node, decorations);
+};
+
+const makeArray = (n: number) => Array.from(Array(n).keys());
+
+/*
+ * This function will create two specific decorations for each cell in a column index target,
+ * for example given that table:
+ *
+ * ```
+ *    0       1      2      3
+ * _____________________ _______
+ * |      |             |      |
+ * |  B1  |     C1      |  A1  |
+ * |______|______ ______|______|
+ * |             |      |      |
+ * |     B2      |      |  A2  |
+ * |______ ______|      |______|
+ * |      |      |  D1  |      |
+ * |  B3  |  C2  |      |  A3  |
+ * |______|______|______|______|
+ *        ^      ^      ^      ^
+ *        |      |      |      |
+ *        |      |      |      |
+ *        |      |      |      |
+ *        0      1      3      4
+ *         \     |      |     /
+ *          \    |      |    /
+ *           \   |      |   /
+ *            \  |      |  /
+ *             \ |      | /
+ *         columnEndIndexTarget === CellColumnPositioning.right
+ * ```
+ *
+ * When a user wants to resize a cell,
+ * they need to grab and hold the end of that column,
+ * and this will be the `columnEndIndexTarget` using
+ * the CellColumnPositioning interface.
+ *
+ * Let's say the `columnEndIndexTarget.right` is 3,
+ * so this function will return two types of decorations for each cell on that column,
+ * that means 2 `resizerHandle` and 2 `lastCellElement`,
+ * here is the explanation for each one of them :
+ *
+ * - resizerHandle:
+ *
+ *   Given the cell C1, this decoration will add a div to create this area
+ * ```
+ *    ▁▁▁▁▁▁▁▁▁▁▁▁▁
+ *   |           ▒▒|
+ *   |     C1    ▒▒|
+ *   |           ▒▒|
+ *    ▔▔▔▔▔▔▔▔▔▔▔▔▔
+ * ```
+ *   This ▒ represents the area where table resizing will start,
+ *   and you can follow that using checking the class name `ClassName.RESIZE_HANDLE_DECORATION` on the code
+ *
+ * - lastCellElementDecoration
+ *
+ *   Given the content of the cell C1
+ *    ▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
+ *   |                   |
+ *   |   _____________   |
+ *   |  |             |  |
+ *   |  |     <p>     |  |
+ *   |  |_____________|  |
+ *   |                   |
+ *   |   _____________   |
+ *   |  |             |  |
+ *   |  |   <media>   |  |
+ *   |  |_____________|  |
+ *   |                   |
+ *   |   _____________   |
+ *   |  |             |  |
+ *   |  |   <media>   |  |
+ *   |  |_____________|  |
+ *   |                   |
+ *    ▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+ *   Currently, we are removing the margin-bottom from the last media using this kind of CSS rule:
+ *   `div:last-of-type`; This is quite unstable, and after we create the `resizerHandle` div,
+ *   that logic will apply the margin in the wrong element, to avoid that,
+ *   we will add a new class on the last item for each cell,
+ *   hence the second media will receive this class `ClassName.LAST_ITEM_IN_CELL`
+ */
+export const createResizeHandleDecoration = (
+  tr: Transaction | ReadonlyTransaction,
+  columnEndIndexTarget: Omit<CellColumnPositioning, 'left'>,
+): [Decoration[], Decoration[]] => {
+  const emptyResult: [Decoration[], Decoration[]] = [[], []];
+  const table = findTable(tr.selection);
+  if (!table || !table.node) {
+    return emptyResult;
+  }
+
+  const map = TableMap.get(table.node);
+  if (!map.width) {
+    return emptyResult;
+  }
+
+  const createResizerHandleDecoration = (
+    cellColumnPositioning: CellColumnPositioning,
+    columnIndex: number,
+    rowIndex: number,
+    cellPos: number,
+    cellNode: PmNode,
+  ): Decoration => {
+    const element = document.createElement('div');
+    element.classList.add(ClassName.RESIZE_HANDLE_DECORATION);
+
+    element.dataset.startIndex = `${cellColumnPositioning.left}`;
+    element.dataset.endIndex = `${cellColumnPositioning.right}`;
+    const position = cellPos + cellNode.nodeSize - 1;
+
+    return Decoration.widget(position, element, {
+      key: `${TableDecorations.COLUMN_RESIZING_HANDLE}_${rowIndex}_${columnIndex}`,
+    });
+  };
+
+  const createLastCellElementDecoration = (
+    cellColumnPositioning: CellColumnPositioning,
+    cellPos: number,
+    cellNode: PmNode,
+  ): Decoration | null => {
+    let lastItemPositions: { from: number; to: number } | undefined;
+    cellNode.forEach((childNode, offset, index) => {
+      if (index === cellNode.childCount - 1) {
+        const from = offset + cellPos + 1;
+        lastItemPositions = {
+          from,
+          to: from + childNode.nodeSize,
+        };
+      }
+    });
+
+    if (!lastItemPositions) {
+      return null;
+    }
+
+    return Decoration.node(
+      lastItemPositions.from,
+      lastItemPositions.to,
+      {
+        class: ClassName.LAST_ITEM_IN_CELL,
+      },
+      {
+        key: `${TableDecorations.LAST_CELL_ELEMENT}_${cellColumnPositioning.left}_${cellColumnPositioning.right}`,
+      },
+    );
+  };
+
+  const resizeHandleCellDecorations: Decoration[] = [];
+  const lastCellElementsDecorations: Array<Decoration | null> = [];
+
+  for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
+    const seen: { [key: number]: boolean } = {};
+
+    for (let columnIndex = 0; columnIndex < map.width; columnIndex++) {
+      const cellPosition = map.map[map.width * rowIndex + columnIndex];
+      if (seen[cellPosition]) {
+        continue;
+      }
+
+      seen[cellPosition] = true;
+      const cellPos = table.start + cellPosition;
+      const cell = tr.doc.nodeAt(cellPos);
+      if (!cell) {
+        continue;
+      }
+      const colspan = (cell.attrs as CellAttributes).colspan || 1;
+      const startIndex = columnIndex;
+      const endIndex = colspan + startIndex;
+
+      if (endIndex !== columnEndIndexTarget.right) {
+        continue;
+      }
+
+      const resizerHandleDec = createResizerHandleDecoration(
+        { left: startIndex, right: endIndex },
+        columnIndex,
+        rowIndex,
+        cellPos,
+        cell,
+      );
+      const lastCellDec = createLastCellElementDecoration(
+        { left: startIndex, right: endIndex },
+        cellPos,
+        cell,
+      );
+
+      resizeHandleCellDecorations.push(resizerHandleDec);
+      lastCellElementsDecorations.push(lastCellDec);
+    }
+  }
+
+  return [
+    resizeHandleCellDecorations,
+    lastCellElementsDecorations.filter(nonNullable),
+  ];
+};
+
+/*
+ * This function will create a decoration for each cell using the right position on the CellColumnPositioning
+ * for example given that table:
+ *
+ * ```
+ *    0       1      2      3   <--- column indexes
+ * _____________________ _______
+ * |      |             |      |
+ * |  B1  |     C1      |  A1  |
+ * |______|______ ______|______|
+ * |             |      |      |
+ * |     B2      |  D1  |  A2  |
+ * |______ ______|______|______|
+ * |      |      |             |
+ * |  B3  |  C2  |      D2     |
+ * |______|______|_____________|
+ * ```
+ *
+ * and given the left and right represents the C1 cell:
+ *
+ * ```
+ *      left          right
+ *        1             3
+ *        |             |
+ *        |             |
+ *        |             |
+ * _______∨_____________∨_______
+ * |      |             |      |
+ * |  B1  |     C1      |  A1  |
+ * |______|______ ______|______|
+ * |             |      |      |
+ * |     B2      |  D1  |  A2  |
+ * |______ ______|______|______|
+ * |      |      |             |
+ * |  B3  |  C2  |      D2     |
+ * |______|______|_____________|
+ * ```
+ *
+ * Taking that table, and the right as parameters,
+ * this function will return two decorations applying a new class `ClassName.WITH_RESIZE_LINE`
+ * only on the cells: `C1` and `D1`.
+ */
+export const createColumnLineResize = (
+  selection: Selection,
+  cellColumnPositioning: Omit<CellColumnPositioning, 'left'>,
+): Decoration[] => {
+  const table = findTable(selection);
+  if (!table || cellColumnPositioning.right === null) {
+    return [];
+  }
+
+  const columnIndex = cellColumnPositioning.right - 1;
+  const map = TableMap.get(table.node);
+
+  const cellPositions = makeArray(map.height)
+    .map((rowIndex) => map.map[map.width * rowIndex + columnIndex])
+    .filter((cellPosition, rowIndex) => {
+      if (columnIndex === map.width) {
+        return true; // If is the last column no filter applied
+      }
+      const nextPosition = map.map[map.width * rowIndex + columnIndex + 1];
+      return cellPosition !== nextPosition; // Removed it if next position is merged
+    });
+
+  const cells = cellPositions.map((pos) => ({
+    pos: pos + table.start,
+    node: table.node.nodeAt(pos),
+  }));
+
+  return cells
+    .map((cell, index) => {
+      if (!cell || !cell.node) {
+        return;
+      }
+
+      return Decoration.node(
+        cell.pos,
+        cell.pos + cell.node.nodeSize,
+        {
+          class: ClassName.WITH_RESIZE_LINE,
+        },
+        {
+          key: `${TableDecorations.COLUMN_RESIZING_HANDLE_LINE}_${cellColumnPositioning.right}_${index}`,
+        },
+      );
+    })
+    .filter(nonNullable);
+};

package/src/plugins/table/utils/dom.ts

@@ -0,0 +1,211 @@
+// import { containsClassName } from '@atlaskit/editor-core/src/utils';
+// import { closestElement } from '@atlaskit/editor-core/src/utils/dom';
+import {
+  closestElement,
+  containsClassName,
+} from '@atlaskit/editor-common/utils';
+import { TableCssClassName as ClassName, ElementContentRects } from '../types';
+import { tableToolbarSize } from '../ui/consts';
+
+const SELECTOR_TABLE_LEAFS = `.${ClassName.TABLE_CELL}, .${ClassName.TABLE_HEADER_CELL}`;
+
+export const isCell = (node: HTMLElement | null): boolean => {
+  return Boolean(
+    node &&
+      (['TH', 'TD'].indexOf(node.tagName) > -1 ||
+        !!closestElement(node, `.${ClassName.TABLE_HEADER_CELL}`) ||
+        !!closestElement(node, `.${ClassName.TABLE_CELL}`)),
+  );
+};
+
+export const isCornerButton = (node: HTMLElement | null): boolean =>
+  containsClassName(node, ClassName.CONTROLS_CORNER_BUTTON);
+
+export const isInsertRowButton = (node: HTMLElement | null) =>
+  containsClassName(node, ClassName.CONTROLS_INSERT_ROW) ||
+  closestElement(node, `.${ClassName.CONTROLS_INSERT_ROW}`) ||
+  (containsClassName(node, ClassName.CONTROLS_BUTTON_OVERLAY) &&
+    closestElement(node, `.${ClassName.ROW_CONTROLS}`));
+
+export const getColumnOrRowIndex = (target: HTMLElement): [number, number] => [
+  parseInt(target.getAttribute('data-start-index') || '-1', 10),
+  parseInt(target.getAttribute('data-end-index') || '-1', 10),
+];
+
+export const isColumnControlsDecorations = (
+  node: HTMLElement | null,
+): boolean => containsClassName(node, ClassName.COLUMN_CONTROLS_DECORATIONS);
+
+export const isRowControlsButton = (node: HTMLElement | null): boolean =>
+  containsClassName(node, ClassName.ROW_CONTROLS_BUTTON) ||
+  containsClassName(node, ClassName.NUMBERED_COLUMN_BUTTON);
+
+export const isResizeHandleDecoration = (node: HTMLElement | null): boolean =>
+  containsClassName(node, ClassName.RESIZE_HANDLE_DECORATION);
+
+export const isTableControlsButton = (node: HTMLElement | null): boolean =>
+  containsClassName(node, ClassName.CONTROLS_BUTTON) ||
+  containsClassName(node, ClassName.ROW_CONTROLS_BUTTON_WRAP);
+
+export const isTableContainerOrWrapper = (node: HTMLElement | null): boolean =>
+  containsClassName(node, ClassName.TABLE_CONTAINER) ||
+  containsClassName(node, ClassName.TABLE_NODE_WRAPPER);
+
+/*
+ * This function returns which side of a given element the mouse cursor is,
+ * using as a base the half of the width by default, for example:
+ *
+ * legend
+ * ⌖ = mouse pointer
+ * ▒ = gap
+ *
+ * given this box:
+ * ┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓
+ * ┃                    ┊                     ┃
+ * ┃       left         ┊        right        ┃
+ * ┃                    ┊                     ┃
+ * ┗━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━┛
+ *
+ * if the mouse is on the left, it will return `left`,
+ * if it is on the right it will return `right`.
+ *
+ * You can extend this behavior using the parameter `gapInPixels`
+ * to determinate if the mouse is inside of a gap for each side,
+ * for example:
+ *
+ * given `gapInPixels` is `5`
+ * and given this box:
+ * ┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓
+ * ┃▒▒▒▒▒               ┊                ▒▒▒▒▒┃
+ * ┃▒▒▒▒▒   left        ┊        right   ▒▒▒▒▒┃
+ * ┃▒▒▒▒▒               ┊                ▒▒▒▒▒┃
+ * ┗━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━┛
+ *
+ * if the mouse cursor is inside of the gap like that:
+ *
+ * ┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓
+ * ┃▒▒▒▒▒               ┊                ▒▒▒▒▒┃
+ * ┃▒▒⌖▒▒   left        ┊        right   ▒▒▒▒▒┃
+ * ┃▒▒▒▒▒               ┊                ▒▒▒▒▒┃
+ * ┗━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━┛
+ *
+ * the function will return `left` because the mouse is inside of the gap on the left side.
+ *
+ * if the mouse cursor is outside of the gap like that:
+ *
+ * ┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓
+ * ┃▒▒▒▒▒               ┊                ▒▒▒▒▒┃
+ * ┃▒▒▒▒▒   left  ⌖     ┊        right   ▒▒▒▒▒┃
+ * ┃▒▒▒▒▒               ┊                ▒▒▒▒▒┃
+ * ┗━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━┛
+ *
+ * the function will return `null` because the mouse is inside of left
+ * but is outside of the gap.
+ *
+ * the same is valid to the right side.
+ */
+
+export const getMousePositionHorizontalRelativeByElement = (
+  mouseEvent: MouseEvent,
+  mouseMoveOptimization?: boolean,
+  elementContentRects?: ElementContentRects,
+  gapInPixels?: number,
+): 'left' | 'right' | null => {
+  const element = mouseEvent.target;
+
+  if (element instanceof HTMLElement) {
+    let width, x;
+    const closestCell = element.closest(SELECTOR_TABLE_LEAFS);
+
+    if (mouseMoveOptimization) {
+      const id = closestCell?.id ?? '';
+      width = elementContentRects?.[id]?.width ?? 0;
+      x = mouseEvent.offsetX;
+    } else {
+      const elementRect = element.getBoundingClientRect();
+      width = elementRect.width;
+      const left = elementRect.left;
+      x = mouseEvent.clientX - left;
+    }
+
+    if (width <= 0) {
+      return null;
+    }
+
+    if (!gapInPixels) {
+      return x / width > 0.5 ? 'right' : 'left';
+    } else {
+      if (x <= gapInPixels) {
+        return 'left';
+      } else if (x >= width - gapInPixels) {
+        return 'right';
+      }
+    }
+  }
+
+  return null;
+};
+
+export const getMousePositionVerticalRelativeByElement = (
+  mouseEvent: MouseEvent,
+): 'top' | 'bottom' | null => {
+  const element = mouseEvent.target;
+  if (element instanceof HTMLElement) {
+    const elementRect = element.getBoundingClientRect();
+    if (elementRect.height <= 0) {
+      return null;
+    }
+
+    const y = mouseEvent.clientY - elementRect.top;
+    return y / elementRect.height > 0.5 ? 'bottom' : 'top';
+  }
+
+  return null;
+};
+
+export const updateResizeHandles = (tableRef?: HTMLElement) => {
+  if (!tableRef) {
+    return;
+  }
+  const height = tableRef.offsetHeight + tableToolbarSize;
+  // see ED-7600
+  const nodes = Array.from(
+    tableRef.querySelectorAll(`.${ClassName.RESIZE_HANDLE}`) as NodeListOf<
+      HTMLElement
+    >,
+  );
+  if (!nodes || !nodes.length) {
+    return;
+  }
+
+  nodes.forEach((node) => {
+    node.style.height = `${height}px`;
+  });
+};
+
+export const hasResizeHandler = ({
+  columnEndIndexTarget,
+  target,
+}: {
+  columnEndIndexTarget: number;
+  target: HTMLElement;
+}): boolean => {
+  const tableElement = closestElement(target, 'table');
+
+  if (!tableElement) {
+    return false;
+  }
+
+  const query = [
+    `.${ClassName.RESIZE_HANDLE_DECORATION}`,
+    `[data-end-index="${columnEndIndexTarget}"]`,
+  ];
+
+  const decorationElement = tableElement.querySelectorAll(query.join(''));
+
+  if (!decorationElement || decorationElement.length === 0) {
+    return false;
+  }
+
+  return true;
+};

package/src/plugins/table/utils/get-allow-add-column-custom-step.ts

@@ -0,0 +1,11 @@
+import { EditorState } from 'prosemirror-state';
+
+import { getPluginState } from '../pm-plugins/plugin-factory';
+
+export function getAllowAddColumnCustomStep(state: EditorState): boolean {
+  const tablePluginState = getPluginState(state);
+  return (
+    Boolean(tablePluginState) &&
+    Boolean(tablePluginState.pluginConfig.allowAddColumnWithCustomStep)
+  );
+}