@atlaskit/editor-tables 3.1.14 → 3.2.0

package/dist/es2019/table-map.js

@@ -1,57 +1,12 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
 /* eslint-disable @atlaskit/editor/no-re-export */
 // Entry file in package.json
 
-// Because working with row and column-spanning cells is not quite
-// trivial, this code builds up a descriptive structure for a given
-// table node. The structures are cached with the (persistent) table
-// nodes as key, so that they only have to be recomputed when the
-// content of the table changes.
-//
-// This does mean that they have to store table-relative, not
-// document-relative positions. So code that uses them will typically
-// compute the start position of the table and offset positions passed
-// to or gotten from this structure by that amount.
-
-let readFromCache, addToCache;
-// Prefer using a weak map to cache table maps. Fall back on a
-// fixed-size cache if that's not supported.
-if (typeof WeakMap !== 'undefined') {
-  const cache = new WeakMap();
-  readFromCache = key => cache.get(key);
-  addToCache = (key, value) => {
-    cache.set(key, value);
-    return value;
-  };
-} else {
-  // Ignored via go/ees005
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const cache = [];
-  const cacheSize = 10;
-  let cachePos = 0;
-  readFromCache = key => {
-    for (let i = 0; i < cache.length; i += 2) {
-      if (cache[i] === key) {
-        return cache[i + 1];
-      }
-    }
-  };
-  addToCache = (key, value) => {
-    if (cachePos === cacheSize) {
-      cachePos = 0;
-    }
-    cache[cachePos++] = key;
-    return cache[cachePos++] = value;
-  };
-}
-export class Rect {
-  constructor(left, top, right, bottom) {
-    this.left = left;
-    this.top = top;
-    this.right = right;
-    this.bottom = bottom;
-  }
-}
+import { addToCache } from './add-to-cache';
+import { computeMap } from './compute-map';
+import { readFromCache } from './read-from-cache';
+import { Rect } from './rect';
 export let TableProblemTypes = /*#__PURE__*/function (TableProblemTypes) {
   TableProblemTypes["COLLISION"] = "collision";
   TableProblemTypes["OVERLONG_ROWSPAN"] = "overlong_rowspan";
@@ -256,199 +211,16 @@ export class TableMap {
   }
 }
 
-// Compute a table map.
-function computeMap(table) {
-  if (table.type.spec.tableRole !== 'table') {
-    throw new RangeError('Not a table node: ' + table.type.name);
-  }
-  const width = findWidth(table);
-  const height = table.childCount;
-  const map = [];
-  const colWidths = [];
-  let mapPos = 0,
-    problems = null;
-  for (let i = 0, e = width * height; i < e; i++) {
-    map[i] = 0;
-  }
-  for (let row = 0, pos = 0; row < height; row++) {
-    const rowNode = table.child(row);
-    pos++;
-    for (let i = 0;; i++) {
-      while (mapPos < map.length && map[mapPos] !== 0) {
-        mapPos++;
-      }
-      if (i === rowNode.childCount) {
-        break;
-      }
-      const cellNode = rowNode.child(i),
-        {
-          colspan,
-          rowspan,
-          colwidth
-        } = cellNode.attrs;
-      for (let h = 0; h < rowspan; h++) {
-        if (h + row >= height) {
-          (problems || (problems = [])).push({
-            type: TableProblemTypes.OVERLONG_ROWSPAN,
-            pos,
-            n: rowspan - h
-          });
-          break;
-        }
-        const start = mapPos + h * width;
-        for (let w = 0; w < colspan; w++) {
-          if (map[start + w] === 0) {
-            map[start + w] = pos;
-          } else {
-            (problems || (problems = [])).push({
-              type: TableProblemTypes.COLLISION,
-              row,
-              pos,
-              n: colspan - w
-            });
-          }
-          const colW = colwidth && colwidth[w];
-          if (colW) {
-            const widthIndex = (start + w) % width * 2,
-              prev = colWidths[widthIndex];
-            if (prev == null || prev !== colW && colWidths[widthIndex + 1] === 1) {
-              colWidths[widthIndex] = colW;
-              colWidths[widthIndex + 1] = 1;
-            } else if (prev === colW) {
-              colWidths[widthIndex + 1]++;
-            }
-          }
-        }
-      }
-      mapPos += colspan;
-      pos += cellNode.nodeSize;
-    }
-    const expectedPos = (row + 1) * width;
-    let missing = 0;
-    while (mapPos < expectedPos) {
-      if (map[mapPos++] === 0) {
-        missing++;
-      }
-    }
-    if (missing) {
-      (problems || (problems = [])).push({
-        type: TableProblemTypes.MISSING,
-        row,
-        n: missing
-      });
-    }
-    pos++;
-  }
-  const mapByRow = Array(height);
-  const mapByColumn = Array(width);
-  for (let i = 0; i < map.length; i++) {
-    var _mapByColumn$columnIn, _mapByRow$rowIndex;
-    const columnIndex = i % width;
-    mapByColumn[columnIndex] = (_mapByColumn$columnIn = mapByColumn[columnIndex]) !== null && _mapByColumn$columnIn !== void 0 ? _mapByColumn$columnIn : [];
-    mapByColumn[columnIndex].push(map[i]);
-    const rowIndex = Math.trunc(i / width);
-    mapByRow[rowIndex] = (_mapByRow$rowIndex = mapByRow[rowIndex]) !== null && _mapByRow$rowIndex !== void 0 ? _mapByRow$rowIndex : [];
-    mapByRow[rowIndex].push(map[i]);
-  }
-  const tableMap = new TableMap(width, height, map, problems, mapByColumn, mapByRow);
-  let badWidths = false;
-
-  // For columns that have defined widths, but whose widths disagree
-  // between rows, fix up the cells whose width doesn't match the
-  // computed one.
-  for (let i = 0; !badWidths && i < colWidths.length; i += 2) {
-    if (colWidths[i] != null && colWidths[i + 1] < height) {
-      badWidths = true;
-    }
-  }
+/**
+ * @deprecated Use `import { Rect } from '@atlaskit/editor-tables/rect'` instead.
+ */
+export { Rect } from './rect';
 
-  // colWidths is an array of numbers, it can look like this
-  // const colWidths = [255, 3, 125, 3, 150, 2, 130, 1];
-  // 255 is a colWidth and 3 is a number of cells with this colwidth.
-  // This check exists to make sure that the table has been resized,
-  // which means there will be elements in the colWidths array.
-  if (colWidths.length > 0 && colWidths.length !== width * 2) {
-    for (let i = 0; i < width * 2 - colWidths.length; i++) {
-      colWidths.push(tableNewColumnMinWidth, 0);
-    }
-    badWidths = true;
-  }
-  if (badWidths) {
-    findBadColWidths(tableMap, colWidths, table);
-  }
-  return tableMap;
-}
-function findWidth(table) {
-  let width = -1;
-  let hasRowSpan = false;
-  for (let row = 0; row < table.childCount; row++) {
-    const rowNode = table.child(row);
-    let rowWidth = 0;
-    if (hasRowSpan) {
-      for (let j = 0; j < row; j++) {
-        const prevRow = table.child(j);
-        for (let i = 0; i < prevRow.childCount; i++) {
-          const cell = prevRow.child(i);
-          if (j + cell.attrs.rowspan > row) {
-            rowWidth += cell.attrs.colspan;
-          }
-        }
-      }
-    }
-    for (let i = 0; i < rowNode.childCount; i++) {
-      const cell = rowNode.child(i);
-      rowWidth += cell.attrs.colspan;
-      if (cell.attrs.rowspan > 1) {
-        hasRowSpan = true;
-      }
-    }
-    if (width === -1) {
-      width = rowWidth;
-    } else if (width !== rowWidth) {
-      width = Math.max(width, rowWidth);
-    }
-  }
-  return width;
-}
-function findBadColWidths(map, colWidths, table) {
-  if (!map.problems) {
-    map.problems = [];
-  }
-  const seen = {};
-  for (let i = 0; i < map.map.length; i++) {
-    const pos = map.map[i];
-    if (seen[pos]) {
-      continue;
-    }
-    seen[pos] = true;
-    const node = table.nodeAt(pos);
-    let updated = null;
-    for (let j = 0; j < node.attrs.colspan; j++) {
-      const col = (i + j) % map.width,
-        colWidth = colWidths[col * 2];
-      if (colWidth != null && (!node.attrs.colwidth || node.attrs.colwidth[j] !== colWidth)) {
-        (updated || (updated = freshColWidth(node.attrs)))[j] = colWidth;
-      }
-    }
-    if (updated) {
-      map.problems.unshift({
-        type: TableProblemTypes.COLWIDTH_MISMATCH,
-        pos,
-        colwidth: updated
-      });
-    }
-  }
-}
-
-// Ignored via go/ees005
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function freshColWidth(attrs) {
-  if (attrs.colwidth) {
-    return attrs.colwidth.slice();
-  }
-  const result = [];
-  for (let i = 0; i < attrs.colspan; i++) {
-    result.push(0);
-  }
-  return result;
-}
+/**
+ * @deprecated Use `import { findWidth } from '@atlaskit/editor-tables/find-width'` instead.
+ */
+export { findWidth } from './find-width';
+/**
+ * @deprecated Use `import { findBadColWidths } from '@atlaskit/editor-tables/find-bad-col-widths'` instead.
+ */
+export { findBadColWidths } from './find-bad-col-widths';

package/dist/es2019/utils/add-col-span.js

@@ -0,0 +1,17 @@
+import { assertColspan } from './assert-colspan';
+
+// TODO: ED-26961 - replace "addColSpan" from table plugin with this function
+export function addColSpan(attrs, pos, n = 1) {
+  assertColspan(attrs);
+  const result = {
+    ...attrs,
+    colspan: attrs.colspan + n
+  };
+  if (result.colwidth) {
+    result.colwidth = result.colwidth.slice();
+    for (let i = 0; i < n; i++) {
+      result.colwidth.splice(pos, 0, 0);
+    }
+  }
+  return result;
+}

package/dist/es2019/utils/add-column-after.js

@@ -0,0 +1,16 @@
+import { addColumn } from './add-column';
+import { isInTable } from './is-in-table';
+import { selectedRect } from './selection-rect';
+
+// :: (EditorState, dispatch: ?(tr: Transaction)) → bool
+// Command to add a column after the column with the selection.
+export const addColumnAfter = (state, dispatch) => {
+  if (!isInTable(state)) {
+    return false;
+  }
+  if (dispatch) {
+    const rect = selectedRect(state);
+    dispatch(addColumn(state.tr, rect, rect.right));
+  }
+  return true;
+};

package/dist/es2019/utils/add-column-at.js

@@ -1,7 +1,7 @@
 import { TableMap } from '../table-map';
 import { addColumn } from './add-column';
 import { cloneTr } from './clone-tr';
-import { findTable } from './find';
+import { findTable } from './find-table';
 
 // Returns a new transaction that adds a new column at index `columnIndex`.
 export const addColumnAt = columnIndex => tr => {

package/dist/es2019/utils/add-column-before.js

@@ -0,0 +1,16 @@
+import { addColumn } from './add-column';
+import { isInTable } from './is-in-table';
+import { selectedRect } from './selection-rect';
+
+// :: (EditorState, dispatch: ?(tr: Transaction)) → bool
+// Command to add a column before the column with the selection.
+export const addColumnBefore = (state, dispatch) => {
+  if (!isInTable(state)) {
+    return false;
+  }
+  if (dispatch) {
+    const rect = selectedRect(state);
+    dispatch(addColumn(state.tr, rect, rect.left));
+  }
+  return true;
+};

package/dist/es2019/utils/add-column.js

@@ -1,15 +1,10 @@
-import { addColSpan, assertColspan } from './colspan';
+import { addColSpan } from './add-col-span';
+import { assertColspan } from './assert-colspan';
+import { columnIsHeader } from './column-is-header';
 import { tableNodeTypes } from './table-node-types';
-export function columnIsHeader(map, table, col) {
-  const headerCell = tableNodeTypes(table.type.schema).header_cell;
-  for (let row = 0; row < map.height; row++) {
-    const cell = table.nodeAt(map.map[col + row * map.width]);
-    if (cell && cell.type !== headerCell) {
-      return false;
-    }
-  }
-  return true;
-}
+
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Preserve the existing public entry-point API.
+export { columnIsHeader } from './column-is-header';
 
 // Add a column at the given position in a table.
 export function addColumn(tr, {

package/dist/es2019/utils/add-row-after.js

@@ -0,0 +1,16 @@
+import { addRow } from './add-row';
+import { isInTable } from './is-in-table';
+import { selectedRect } from './selection-rect';
+
+// :: (EditorState, dispatch: ?(tr: Transaction)) → bool
+// Add a table row after the selection.
+export const addRowAfter = (state, dispatch) => {
+  if (!isInTable(state)) {
+    return false;
+  }
+  if (dispatch) {
+    const rect = selectedRect(state);
+    dispatch(addRow(state.tr, rect, rect.bottom));
+  }
+  return true;
+};

package/dist/es2019/utils/add-row-at.js

@@ -1,76 +1,8 @@
-import { safeInsert } from '@atlaskit/editor-prosemirror/utils';
 import { TableMap } from '../table-map';
 import { addRow } from './add-row';
+import { cloneRowAt } from './clone-row-at';
 import { cloneTr } from './clone-tr';
-import { findTable } from './find';
-import { getCellsInRow } from './get-cells-in-row';
-import { setCellAttrs } from './set-cell-attrs';
-import { tableNodeTypes } from './table-node-types';
-const filterCellsInRow = (rowIndex, predicate) => tr => {
-  const foundCells = [];
-  const cells = getCellsInRow(rowIndex)(tr.selection);
-  if (cells) {
-    for (let j = cells.length - 1; j >= 0; j--) {
-      if (predicate(cells[j], tr)) {
-        foundCells.push(cells[j]);
-      }
-    }
-  }
-  return foundCells;
-};
-
-// Returns a new transaction that adds a new row after `cloneRowIndex`, cloning the row attributes at `cloneRowIndex`.
-export const cloneRowAt = rowIndex => tr => {
-  const table = findTable(tr.selection);
-  if (table) {
-    const map = TableMap.get(table.node);
-    if (rowIndex >= 0 && rowIndex <= map.height) {
-      const tableNode = table.node;
-      const tableNodes = tableNodeTypes(tableNode.type.schema);
-      let rowPos = table.start;
-      for (let i = 0; i < rowIndex + 1; i++) {
-        rowPos += tableNode.child(i).nodeSize;
-      }
-      const cloneRow = tableNode.child(rowIndex);
-      // Re-create the same nodes with same attrs, dropping the node content.
-      const cells = [];
-      let rowWidth = 0;
-      cloneRow.forEach(cell => {
-        // If we're copying a row with rowspan somewhere, we dont want to copy that cell
-        // We'll increment its span below.
-        if (cell.attrs.rowspan === 1) {
-          rowWidth += cell.attrs.colspan;
-          const node = tableNodes[cell.type.spec.tableRole].createAndFill(cell.attrs, [], cell.marks);
-          if (node) {
-            cells.push(node);
-          }
-        }
-      });
-
-      // If a higher row spans past our clone row, bump the higher row to cover this new row too.
-      if (rowWidth < map.width) {
-        const rowSpanCells = [];
-        for (let i = rowIndex; i >= 0; i--) {
-          const foundCells = filterCellsInRow(i, (cell, _tr) => {
-            const rowspan = cell.node.attrs.rowspan;
-            const spanRange = i + rowspan;
-            return rowspan > 1 && spanRange > rowIndex;
-          })(tr);
-          rowSpanCells.push(...foundCells);
-        }
-        if (rowSpanCells.length) {
-          rowSpanCells.forEach(cell => {
-            tr = setCellAttrs(cell, {
-              rowspan: cell.node.attrs.rowspan + 1
-            })(tr);
-          });
-        }
-      }
-      return safeInsert(tableNodes.row.create(cloneRow.attrs, cells), rowPos)(tr);
-    }
-  }
-  return tr;
-};
+import { findTable } from './find-table';
 
 // Returns a new transaction that adds a new row at index `rowIndex`. Optionally clone the previous row.
 export const addRowAt = (rowIndex, clonePreviousRow) => tr => {

package/dist/es2019/utils/add-row-before.js

@@ -0,0 +1,16 @@
+import { addRow } from './add-row';
+import { isInTable } from './is-in-table';
+import { selectedRect } from './selection-rect';
+
+// :: (EditorState, dispatch: ?(tr: Transaction)) → bool
+// Add a table row before the selection.
+export const addRowBefore = (state, dispatch) => {
+  if (!isInTable(state)) {
+    return false;
+  }
+  if (dispatch) {
+    const rect = selectedRect(state);
+    dispatch(addRow(state.tr, rect, rect.top));
+  }
+  return true;
+};

package/dist/es2019/utils/analytics-helpers.js

@@ -1,46 +1,12 @@
-import { TableMap } from '../table-map';
-import { findTable } from './find';
-import { getSelectionRect } from './get-selection-rect';
-export function getSelectedTableInfo(selection) {
-  let map;
-  let totalRowCount = 0;
-  let totalColumnCount = 0;
-  const table = findTable(selection);
-  if (table) {
-    map = TableMap.get(table.node);
-    totalRowCount = map.height;
-    totalColumnCount = map.width;
-  }
-  return {
-    table,
-    map,
-    totalRowCount,
-    totalColumnCount
-  };
-}
-export function getSelectedCellInfo(selection) {
-  let horizontalCells = 1;
-  let verticalCells = 1;
-  let totalCells = 1;
-  const {
-    table,
-    map,
-    totalRowCount,
-    totalColumnCount
-  } = getSelectedTableInfo(selection);
-  if (table && map) {
-    const rect = getSelectionRect(selection);
-    if (rect) {
-      totalCells = map.cellsInRect(rect).length;
-      horizontalCells = rect.right - rect.left;
-      verticalCells = rect.bottom - rect.top;
-    }
-  }
-  return {
-    totalRowCount,
-    totalColumnCount,
-    horizontalCells,
-    verticalCells,
-    totalCells
-  };
-}
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
+
+/**
+ * @deprecated Use `import { getSelectedTableInfo } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { getSelectedTableInfo } from './get-selected-table-info';
+/**
+ * @deprecated Use `import { getSelectedCellInfo } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { getSelectedCellInfo } from './get-selected-cell-info';

package/dist/es2019/utils/array-of-rows.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/utils/assert-colspan.js

@@ -0,0 +1,8 @@
+export function assertColspan(attrs) {
+  if (typeof attrs.colspan === 'undefined') {
+    throw new Error('addColSpan: attrs.colspan is not defined');
+  }
+  if (typeof attrs.colspan !== 'number' || Number.isNaN(attrs.colspan) || attrs.colspan < 1) {
+    throw new Error(`addColSpan: attrs.colspan must be number >= 1, received: ${attrs.colspan}`);
+  }
+}

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

@@ -0,0 +1,8 @@
+export function cellAround($pos) {
+  for (let d = $pos.depth - 1; d > 0; d--) {
+    if ($pos.node(d).type.spec.tableRole === 'row') {
+      return $pos.node(0).resolve($pos.before(d + 1));
+    }
+  }
+  return null;
+}

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

@@ -0,0 +1,19 @@
+export function cellNear($pos) {
+  for (let after = $pos.nodeAfter, {
+      pos
+    } = $pos; after; after = after.firstChild, pos++) {
+    const role = after.type.spec.tableRole;
+    if (role === 'cell' || role === 'header_cell') {
+      return $pos.doc.resolve(pos);
+    }
+  }
+  for (let before = $pos.nodeBefore, {
+      pos
+    } = $pos; before; before = before.lastChild, pos--) {
+    const role = before.type.spec.tableRole;
+    if (role === 'cell' || role === 'header_cell') {
+      return $pos.doc.resolve(pos - before.nodeSize);
+    }
+  }
+  return null;
+}

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

@@ -0,0 +1,10 @@
+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;
+}

package/dist/es2019/utils/cells.js

@@ -1,39 +1,22 @@
-// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
 
-import { TableMap } from '../table-map';
-export function pointsAtCell($pos) {
-  return $pos.parent.type.spec.tableRole === 'row' && $pos.nodeAfter;
-}
-export function cellNear($pos) {
-  for (let after = $pos.nodeAfter, {
-      pos
-    } = $pos; after; after = after.firstChild, pos++) {
-    const role = after.type.spec.tableRole;
-    if (role === 'cell' || role === 'header_cell') {
-      return $pos.doc.resolve(pos);
-    }
-  }
-  for (let before = $pos.nodeBefore, {
-      pos
-    } = $pos; before; before = before.lastChild, pos--) {
-    const role = before.type.spec.tableRole;
-    if (role === 'cell' || role === 'header_cell') {
-      return $pos.doc.resolve(pos - before.nodeSize);
-    }
-  }
-  return null;
-}
-export function cellAround($pos) {
-  for (let d = $pos.depth - 1; d > 0; d--) {
-    if ($pos.node(d).type.spec.tableRole === 'row') {
-      return $pos.node(0).resolve($pos.before(d + 1));
-    }
-  }
-  return null;
-}
-export function nextCell($pos, axis, dir) {
-  const start = $pos.start(-1);
-  const map = TableMap.get($pos.node(-1));
-  const moved = map.nextCell($pos.pos - start, axis, dir);
-  return moved == null ? null : $pos.node(0).resolve(start + moved);
-}
+/**
+ * @deprecated Use `import { pointsAtCell } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { pointsAtCell } from './points-at-cell';
+/**
+ * @deprecated Use `import { cellNear } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { cellNear } from './cell-near';
+/**
+ * @deprecated Use `import { cellAround } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { cellAround } from './cell-around';
+/**
+ * @deprecated Use `import { nextCell } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { nextCell } from './next-cell';