@atlaskit/editor-plugin-table 0.0.0 → 0.0.1

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

@@ -0,0 +1,107 @@
+import { Selection, Transaction } from 'prosemirror-state';
+import { TableMap, Rect } from '@atlaskit/editor-tables/table-map';
+import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
+import {
+  findTable,
+  getSelectionRangeInColumn,
+  getSelectionRangeInRow,
+  getSelectionRect,
+  isSelectionType,
+} from '@atlaskit/editor-tables/utils';
+
+export const isSelectionUpdated = (
+  oldSelection: Selection,
+  newSelection?: Selection,
+) =>
+  !!(!newSelection && oldSelection) ||
+  isSelectionType(oldSelection, 'cell') !==
+    isSelectionType(newSelection!, 'cell') ||
+  (isSelectionType(oldSelection, 'cell') &&
+    isSelectionType(newSelection!, 'cell') &&
+    oldSelection.ranges !== newSelection!.ranges);
+
+const isRectangularCellSelection = (
+  selection: Selection,
+  rect: Rect,
+): boolean => {
+  const table = findTable(selection);
+  if (!table) {
+    return true;
+  }
+  const { width, height, map } = TableMap.get(table.node);
+
+  let indexTop = rect.top * width + rect.left;
+  let indexLeft = indexTop;
+  let indexBottom = (rect.bottom - 1) * width + rect.left;
+  let indexRight = indexTop + (rect.right - rect.left - 1);
+
+  for (let i = rect.top; i < rect.bottom; i++) {
+    if (
+      (rect.left > 0 && map[indexLeft] === map[indexLeft - 1]) ||
+      (rect.right < width && map[indexRight] === map[indexRight + 1])
+    ) {
+      return false;
+    }
+    indexLeft += width;
+    indexRight += width;
+  }
+  for (let i = rect.left; i < rect.right; i++) {
+    if (
+      (rect.top > 0 && map[indexTop] === map[indexTop - width]) ||
+      (rect.bottom < height && map[indexBottom] === map[indexBottom + width])
+    ) {
+      return false;
+    }
+    indexTop++;
+    indexBottom++;
+  }
+
+  return true;
+};
+
+export const normalizeSelection = (tr: Transaction): Transaction => {
+  const { selection } = tr;
+  const rect = getSelectionRect(selection);
+
+  if (
+    !rect ||
+    !(selection instanceof CellSelection) ||
+    isRectangularCellSelection(selection, rect)
+  ) {
+    return tr;
+  }
+
+  if (selection.isColSelection()) {
+    const $anchor = getSelectionRangeInColumn(rect.left)(tr)?.$anchor;
+    const $head = getSelectionRangeInColumn(rect.right - 1)(tr)?.$head;
+    if ($anchor && $head) {
+      return tr.setSelection(new CellSelection($anchor, $head) as any);
+    }
+  }
+
+  if (selection.isRowSelection()) {
+    const $anchor = getSelectionRangeInRow(rect.top)(tr)?.$anchor;
+    const $head = getSelectionRangeInRow(rect.bottom - 1)(tr)?.$head;
+    if ($anchor && $head) {
+      return tr.setSelection(new CellSelection($anchor, $head) as any);
+    }
+  }
+
+  return tr;
+};
+
+export const getSelectedColumnIndexes = (selectionRect: Rect): number[] => {
+  const columnIndexes: number[] = [];
+  for (let i = selectionRect.left; i < selectionRect.right; i++) {
+    columnIndexes.push(i);
+  }
+  return columnIndexes;
+};
+
+export const getSelectedRowIndexes = (selectionRect: Rect): number[] => {
+  const rowIndexes: number[] = [];
+  for (let i = selectionRect.top; i < selectionRect.bottom; i++) {
+    rowIndexes.push(i);
+  }
+  return rowIndexes;
+};

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

@@ -0,0 +1,31 @@
+import { Transaction } from 'prosemirror-state';
+import { TableMap, Rect } from '@atlaskit/editor-tables/table-map';
+import { findTable } from '@atlaskit/editor-tables/utils';
+
+export const getMergedCellsPositions = (tr: Transaction): number[] => {
+  const table = findTable(tr.selection);
+  if (!table) {
+    return [];
+  }
+
+  const map = TableMap.get(table.node);
+  const cellPositions = new Set();
+  const mergedCells: number[] = [];
+
+  map.map.forEach((value) => {
+    if (cellPositions.has(value)) {
+      mergedCells.push(value);
+    } else {
+      cellPositions.add(value);
+    }
+  });
+
+  return mergedCells;
+};
+
+export const colsToRect = (cols: Array<number>, noOfRows: number): Rect => ({
+  left: Math.min(...cols),
+  right: Math.max(...cols) + 1,
+  top: 0,
+  bottom: noOfRows,
+});

package/src/plugins/table/utils/update-plugin-state-decorations.ts

@@ -0,0 +1,14 @@
+import { EditorState } from 'prosemirror-state';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+
+import { getDecorations } from '../pm-plugins/decorations/plugin';
+import { TableDecorations } from '../types';
+
+import { updateDecorations } from './decoration';
+
+export const updatePluginStateDecorations = (
+  state: EditorState<any>,
+  decorations: Decoration[],
+  key: TableDecorations,
+): DecorationSet =>
+  updateDecorations(state.doc, getDecorations(state), decorations, key);

package/src/plugins/table-plugin.ts

@@ -1,40 +1,3 @@
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { pluginKey } from './plugin-key';
-import { Mark } from 'prosemirror-model';
-import { EditorView } from 'prosemirror-view';
-
-function createPlugin() {
-  return new SafePlugin({
-    key: pluginKey,
-    state: {
-      init() {
-        const z = { Mark, EditorView };
-        // eslint-disable-next-line no-console
-        console.log('delete to use prosemirror-model/view', z);
-        // eslint-disable-next-line no-console
-        console.log('next table plugin loaded');
-        return {
-          scaffold: true,
-        };
-      },
-      apply() {},
-    },
-  });
-}
-
-// const tablesPlugin = (options?: TablePluginOptions): any => ({
-const tablesPlugin = (): any => ({
-  name: 'nextTable',
-  pmPlugins() {
-    return [
-      {
-        name: 'next-table-scaffold',
-        plugin: () => {
-          return createPlugin();
-        },
-      },
-    ];
-  },
-});
+import { default as tablesPlugin } from './table';
 
 export default tablesPlugin;