@atlaskit/editor-tables 3.1.14 → 3.2.0

package/dist/es2019/utils/remove-selected-rows.js

@@ -0,0 +1,43 @@
+import { TableMap } from '../table-map';
+import { cloneTr } from './clone-tr';
+import { findTable } from './find-table';
+import { isSelectionType } from './is-selection-type';
+import { isTableSelected } from './is-table-selected';
+import { removeRow } from './remove-row';
+import { removeTable } from './remove-table';
+
+// Returns a new transaction that removes selected rows.
+export const removeSelectedRows = tr => {
+  const {
+    selection
+  } = tr;
+  if (isTableSelected(selection)) {
+    return removeTable(tr);
+  }
+  if (isSelectionType(selection, 'cell')) {
+    const table = findTable(selection);
+    if (table) {
+      const map = TableMap.get(table.node);
+      const rect = map.rectBetween(selection.$anchorCell.pos - table.start, selection.$headCell.pos - table.start);
+      if (rect.top === 0 && rect.bottom === map.height) {
+        return tr;
+      }
+      const pmTableRect = {
+        ...rect,
+        map,
+        table: table.node,
+        tableStart: table.start
+      };
+      for (let i = pmTableRect.bottom - 1;; i--) {
+        removeRow(tr, pmTableRect, i);
+        if (i === pmTableRect.top) {
+          break;
+        }
+        pmTableRect.table = pmTableRect.tableStart ? tr.doc.nodeAt(pmTableRect.tableStart - 1) : tr.doc;
+        pmTableRect.map = TableMap.get(pmTableRect.table);
+      }
+      return cloneTr(tr);
+    }
+  }
+  return tr;
+};

package/dist/es2019/utils/reorder-utils.js

@@ -1,180 +1,42 @@
-import { TableMap } from '../table-map';
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
 
-// array = [
-//   [A1, B1, C1, null],
-//   [A2, B2, null, D1],
-//   [A3. B3, C2, null],
-// ]
+/**
+ * @deprecated Use `import { transpose } from '@atlaskit/editor-tables/utils/reorder-utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { transpose } from './transpose';
+/**
+ * @deprecated Use `import { convertArrayOfRowsToTableNode } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { convertArrayOfRowsToTableNode } from './convert-array-of-rows-to-table-node';
+/**
+ * @deprecated Use `import { convertTableNodeToArrayOfRows } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { convertTableNodeToArrayOfRows } from './convert-table-node-to-array-of-rows';
+/**
+ * @deprecated Use `import { moveTableRow } from '@atlaskit/editor-tables/utils/reorder-utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { moveTableRow } from './move-table-row';
+/**
+ * @deprecated Use `import { moveTableColumn } from '@atlaskit/editor-tables/utils/reorder-utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { moveTableColumn } from './move-table-column';
+/**
+ * @deprecated Use `import { isValidReorder } from '@atlaskit/editor-tables/utils/reorder-utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { isValidReorder } from './is-valid-reorder';
+/**
+ * @deprecated Use `import type { ArrayOfRows } from '@atlaskit/editor-tables/utils/reorder-utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
 
-// This function transposes an array of array flipping the columns for rows,
-// transposition is a familiar algebra concept;
-// you can get more details here:
-// https://en.wikipedia.org/wiki/Transpose
-//
-// ```javascript
-//
-//  const arr = [
-//    ['a1', 'a2', 'a3'],
-//    ['b1', 'b2', 'b3'],
-//    ['c1', 'c2', 'c3'],
-//    ['d1', 'd2', 'd3'],
-//  ];
-//
-//  const result = transpose(arr);
-//
-//  result === [
-//    ['a1', 'b1', 'c1', 'd1'],
-//    ['a2', 'b2', 'c2', 'd2'],
-//    ['a3', 'b3', 'c3', 'd3'],
-//  ]
-// ```
-// Ignored via go/ees005
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const transpose = array => {
-  // Ignored via go/ees005
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return array[0].map((_, i) => {
-    return array.map(column => column[i]);
-  });
-};
-
-// :: (tableNode: Node, tableArray: Array<Node>) -> Node
-// This function will transform a matrix of nodes
-// into table node respecting merged cells and rows configurations,
-// for example this array will be convert to the table below:
-//
-// ```javascript
-// array = [
-//   [A1, B1, C1, null],
-//   [A2, B2, null, D1],
-//   [A3. B3, C2, null],
-// ]
-// ```
-//
-// ```
-//  ____________________________
-// |      |      |             |
-// |  A1  |  B1  |     C1      |
-// |______|______|______ ______|
-// |      |             |      |
-// |  A2  |     B2      |      |
-// |______|______ ______|      |
-// |      |      |      |  D1  |
-// |  A3  |  B3  |  C2  |      |
-// |______|______|______|______|
-// ```
-//
-export const convertArrayOfRowsToTableNode = (tableNode, arrayOfNodes) => {
-  const rowsPM = [];
-  const map = TableMap.get(tableNode);
-  for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
-    const row = tableNode.child(rowIndex);
-    const rowCells = [];
-    for (let colIndex = 0; colIndex < map.width; colIndex++) {
-      if (!arrayOfNodes[rowIndex][colIndex]) {
-        continue;
-      }
-      const cellPos = map.map[rowIndex * map.width + colIndex];
-      const cell = arrayOfNodes[rowIndex][colIndex];
-      const oldCell = tableNode.nodeAt(cellPos);
-      if (!cell || !oldCell) {
-        continue;
-      }
-      const newCell = oldCell.type.createChecked(Object.assign({}, cell.attrs), cell.content, cell.marks);
-      rowCells.push(newCell);
-    }
-    rowsPM.push(row.type.createChecked(row.attrs, rowCells, row.marks));
-  }
-  const newTable = tableNode.type.createChecked(tableNode.attrs, rowsPM, tableNode.marks);
-  return newTable;
-};
-const moveRowInArrayOfRows = (arrayOfNodes, indexesOrigin, indexesTarget, directionOverride) => {
-  const direction = indexesOrigin[0] > indexesTarget[0] ? -1 : 1;
-  const rowsExtracted = arrayOfNodes.splice(indexesOrigin[0], indexesOrigin.length);
-  const positionOffset = rowsExtracted.length % 2 === 0 ? 1 : 0;
-  let target;
-  if (directionOverride === -1 && direction === 1) {
-    target = indexesTarget[0] - 1;
-  } else if (directionOverride === 1 && direction === -1) {
-    target = indexesTarget[indexesTarget.length - 1] - positionOffset + 1;
-  } else {
-    target = direction === -1 ? indexesTarget[0] : indexesTarget[indexesTarget.length - 1] - positionOffset;
-  }
-
-  // @ts-ignore no idea what this line does
-  arrayOfNodes.splice.apply(arrayOfNodes, [target, 0].concat(rowsExtracted));
-  return arrayOfNodes;
-};
-
-// :: (tableNode: Node) -> Array<Node>
-// This function will transform the table node
-// into a matrix of rows and columns respecting merged cells,
-// for example this table will be convert to the below:
-//
-// ```
-//  ____________________________
-// |      |      |             |
-// |  A1  |  B1  |     C1      |
-// |______|______|______ ______|
-// |      |             |      |
-// |  A2  |     B2      |      |
-// |______|______ ______|      |
-// |      |      |      |  D1  |
-// |  A3  |  B3  |  C2  |      |
-// |______|______|______|______|
-// ```
-//
-//
-// ```javascript
-// array = [
-//   [A1, B1, C1, null],
-//   [A2, B2, null, D1],
-//   [A3. B3, C2, null],
-// ]
-// ```
-export const convertTableNodeToArrayOfRows = tableNode => {
-  const map = TableMap.get(tableNode);
-  const rows = [];
-  for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
-    const rowCells = [];
-    const seen = {};
-    for (let colIndex = 0; colIndex < map.width; colIndex++) {
-      const cellPos = map.map[rowIndex * map.width + colIndex];
-      const cell = tableNode.nodeAt(cellPos);
-      const rect = map.findCell(cellPos);
-      if (!cell || seen[cellPos] || rect.top !== rowIndex) {
-        rowCells.push(null);
-        continue;
-      }
-      seen[cellPos] = true;
-      rowCells.push(cell);
-    }
-    rows.push(rowCells);
-  }
-  return rows;
-};
-export const moveTableRow = (table, indexesOrigin, indexesTarget, direction) => {
-  let rows = convertTableNodeToArrayOfRows(table.node);
-  rows = moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget, direction);
-  return convertArrayOfRowsToTableNode(table.node, rows);
-};
-export const moveTableColumn = (table, indexesOrigin, indexesTarget, direction) => {
-  let rows = transpose(convertTableNodeToArrayOfRows(table.node));
-  rows = moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget, direction);
-  rows = transpose(rows);
-  return convertArrayOfRowsToTableNode(table.node, rows);
-};
-export const isValidReorder = (originIndex, targetIndex, targets, type) => {
-  const direction = originIndex > targetIndex ? -1 : 1;
-  const errorMessage = `Target position is invalid, you can't move the ${type} ${originIndex} to ${targetIndex}, the target can't be split. You could use tryToFit option.`;
-  if (direction === 1) {
-    if (targets.slice(0, targets.length - 1).indexOf(targetIndex) !== -1) {
-      throw new Error(errorMessage);
-    }
-  } else {
-    if (targets.slice(1).indexOf(targetIndex) !== -1) {
-      throw new Error(errorMessage);
-    }
-  }
-  return true;
-};
+/**
+ * @deprecated Use `import { moveRowInArrayOfRows } from '@atlaskit/editor-tables/utils/reorder-utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { moveRowInArrayOfRows } from './move-row-in-array-of-rows';

package/dist/es2019/utils/replace-table.js

@@ -1,7 +1,7 @@
 import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
 import { TextSelection } from '@atlaskit/editor-prosemirror/state';
-import { findTable } from './find';
-import { isTableSelected } from './is-selected';
+import { findTable } from './find-table';
+import { isTableSelected } from './is-table-selected';
 export const replaceSelectedTable = (state, content) => {
   if (isTableSelected(state.selection)) {
     const table = findTable(state.selection);

package/dist/es2019/utils/select-nodes.js

@@ -1,8 +1,10 @@
-import { editorExperiment } from '@atlaskit/tmp-editor-statsig/editor-experiment';
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
+
 import { CellSelection } from '../cell-selection';
 import { TableMap } from '../table-map';
 import { cloneTr } from './clone-tr';
-import { findCellClosestToPos, findTable, findTableClosestToPos } from './find';
+import { findCellClosestToPos } from './find-cell-closest-to-pos';
+import { findTable } from './find-table';
 const select = type => (index, expand) => tr => {
   const table = findTable(tr.selection);
   const isRowSelection = type === 'row';
@@ -135,60 +137,18 @@ export const selectRows = selectRowsOrColumns('rows');
 // Returns a new transaction that selects all columns at `indexes`.
 export const selectColumns = selectRowsOrColumns('columns');
 
-// Returns a new transaction that selects a table.
-export const selectTable = tr => {
-  const table = findTable(tr.selection);
-  if (table) {
-    const {
-      map
-    } = TableMap.get(table.node);
-    if (map && map.length) {
-      const head = table.start + map[0];
-      const anchor = table.start + map[map.length - 1];
-      const $head = tr.doc.resolve(head);
-      const $anchor = tr.doc.resolve(anchor);
-      return cloneTr(tr.setSelection(new CellSelection($anchor, $head)));
-    }
-  }
-  return tr;
-};
-export const getTableSelectionClosesToPos = $pos => {
-  const table = findTableClosestToPos($pos);
-  if (table) {
-    const {
-      map
-    } = TableMap.get(table.node);
-    if (map && map.length) {
-      const head = table.start + map[0];
-      const anchor = table.start + map[map.length - 1];
-      const $head = $pos.doc.resolve(head);
-      const $anchor = $pos.doc.resolve(anchor);
-      return new CellSelection($anchor, $head);
-    }
-  }
-};
-export const selectTableClosestToPos = (tr, $pos) => {
-  if (editorExperiment('platform_editor_block_menu', true, {
-    exposure: true
-  })) {
-    const tableSelection = getTableSelectionClosesToPos($pos);
-    if (tableSelection) {
-      return cloneTr(tr.setSelection(tableSelection));
-    }
-    return tr;
-  }
-  const table = findTableClosestToPos($pos);
-  if (table) {
-    const {
-      map
-    } = TableMap.get(table.node);
-    if (map && map.length) {
-      const head = table.start + map[0];
-      const anchor = table.start + map[map.length - 1];
-      const $head = tr.doc.resolve(head);
-      const $anchor = tr.doc.resolve(anchor);
-      return cloneTr(tr.setSelection(new CellSelection($anchor, $head)));
-    }
-  }
-  return tr;
-};
+/**
+ * @deprecated Use `import { selectTable } from '@atlaskit/editor-tables/select-table'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { selectTable } from './select-table';
+/**
+ * @deprecated Use `import { getTableSelectionClosesToPos } from '@atlaskit/editor-tables/get-table-selection-closes-to-pos'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { getTableSelectionClosesToPos } from './get-table-selection-closes-to-pos';
+/**
+ * @deprecated Use `import { selectTableClosestToPos } from '@atlaskit/editor-tables/select-table-closest-to-pos'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { selectTableClosestToPos } from './select-table-closest-to-pos';

package/dist/es2019/utils/select-table-closest-to-pos.js

@@ -0,0 +1,31 @@
+import { editorExperiment } from '@atlaskit/tmp-editor-statsig/editor-experiment';
+import { CellSelection } from '../cell-selection';
+import { TableMap } from '../table-map';
+import { cloneTr } from './clone-tr';
+import { findTableClosestToPos } from './find-table-closest-to-pos';
+import { getTableSelectionClosesToPos } from './get-table-selection-closes-to-pos';
+export const selectTableClosestToPos = (tr, $pos) => {
+  if (editorExperiment('platform_editor_block_menu', true, {
+    exposure: true
+  })) {
+    const tableSelection = getTableSelectionClosesToPos($pos);
+    if (tableSelection) {
+      return cloneTr(tr.setSelection(tableSelection));
+    }
+    return tr;
+  }
+  const table = findTableClosestToPos($pos);
+  if (table) {
+    const {
+      map
+    } = TableMap.get(table.node);
+    if (map && map.length) {
+      const head = table.start + map[0];
+      const anchor = table.start + map[map.length - 1];
+      const $head = tr.doc.resolve(head);
+      const $anchor = tr.doc.resolve(anchor);
+      return cloneTr(tr.setSelection(new CellSelection($anchor, $head)));
+    }
+  }
+  return tr;
+};

package/dist/es2019/utils/select-table.js

@@ -0,0 +1,22 @@
+import { CellSelection } from '../cell-selection';
+import { TableMap } from '../table-map';
+import { cloneTr } from './clone-tr';
+import { findTable } from './find-table';
+
+// Returns a new transaction that selects a table.
+export const selectTable = tr => {
+  const table = findTable(tr.selection);
+  if (table) {
+    const {
+      map
+    } = TableMap.get(table.node);
+    if (map && map.length) {
+      const head = table.start + map[0];
+      const anchor = table.start + map[map.length - 1];
+      const $head = tr.doc.resolve(head);
+      const $anchor = tr.doc.resolve(anchor);
+      return cloneTr(tr.setSelection(new CellSelection($anchor, $head)));
+    }
+  }
+  return tr;
+};

package/dist/es2019/utils/selection-cell.js

@@ -1,4 +1,5 @@
-import { cellAround, cellNear } from './cells';
+import { cellAround } from './cell-around';
+import { cellNear } from './cell-near';
 import { isSelectionType } from './is-selection-type';
 export function selectionCell(selection) {
   if (isSelectionType(selection, 'cell')) {

package/dist/es2019/utils/split-cell-with-type.js

@@ -1,17 +1,11 @@
 import { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
 import { CellSelection } from '../cell-selection';
-import { cellAround } from './cells';
+import { cellAround } from './cell-around';
+import { cellWrapping } from './cell-wrapping';
 import { selectedRect } from './selection-rect';
-export function cellWrapping($pos) {
-  for (let d = $pos.depth; d > 0; d--) {
-    // Sometimes the cell can be in the same depth.
-    const role = $pos.node(d).type.spec.tableRole;
-    if (role === 'cell' || role === 'header_cell') {
-      return $pos.node(d);
-    }
-  }
-  return null;
-}
+
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Preserve the existing public entry-point API.
+export { cellWrapping } from './cell-wrapping';
 // Split a selected cell, whose rowpan or colspan is greater than one,
 // into smaller cells with the cell type (th, td) returned by getType function.
 export function splitCellWithType(getCellType) {

package/dist/es2019/utils/tables.js

@@ -1,14 +1,12 @@
-export function isInTable(state) {
-  const {
-    $head
-  } = state.selection;
-  for (let d = $head.depth; d > 0; d--) {
-    if ($head.node(d).type.spec.tableRole === 'row') {
-      return true;
-    }
-  }
-  return false;
-}
-export function inSameTable($a, $b) {
-  return $a.depth === $b.depth && $a.pos >= $b.start(-1) && $a.pos <= $b.end(-1);
-}
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
+
+/**
+ * @deprecated Use `import { isInTable } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { isInTable } from './is-in-table';
+/**
+ * @deprecated Use `import { inSameTable } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { inSameTable } from './in-same-table';

package/dist/es2019/utils/toggle-header.js

@@ -1,24 +1,8 @@
-import { Rect } from '../table-map';
+import { Rect } from '../rect';
+import { isHeaderEnabledByType } from './is-header-enabled-by-type';
+import { isInTable } from './is-in-table';
 import { selectedRect } from './selection-rect';
 import { tableNodeTypes } from './table-node-types';
-import { isInTable } from './tables';
-export function isHeaderEnabledByType(type, rect, types) {
-  // Get cell positions for first row or first column
-  const cellPositions = rect.map.cellsInRect({
-    left: 0,
-    top: 0,
-    right: type === 'row' ? rect.map.width : 1,
-    bottom: type === 'column' ? rect.map.height : 1
-  });
-  for (let i = 0; i < cellPositions.length; i++) {
-    const cell = rect.table.nodeAt(cellPositions[i]);
-    if (cell && cell.type !== types.header_cell) {
-      return false;
-    }
-  }
-  return true;
-}
-
 // Toggles between row/column header and normal cells (Only applies to first row/column).
 export function toggleHeader(type) {
   return function (state, dispatch) {

package/dist/es2019/utils/transpose.js

@@ -0,0 +1,31 @@
+// This function transposes an array of array flipping the columns for rows,
+// transposition is a familiar algebra concept;
+// you can get more details here:
+// https://en.wikipedia.org/wiki/Transpose
+//
+// ```javascript
+//
+//  const arr = [
+//    ['a1', 'a2', 'a3'],
+//    ['b1', 'b2', 'b3'],
+//    ['c1', 'c2', 'c3'],
+//    ['d1', 'd2', 'd3'],
+//  ];
+//
+//  const result = transpose(arr);
+//
+//  result === [
+//    ['a1', 'b1', 'c1', 'd1'],
+//    ['a2', 'b2', 'c2', 'd2'],
+//    ['a3', 'b3', 'c3', 'd3'],
+//  ]
+// ```
+// Ignored via go/ees005
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const transpose = array => {
+  // Ignored via go/ees005
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return array[0].map((_, i) => {
+    return array.map(column => column[i]);
+  });
+};