@atlaskit/editor-plugin-table 1.1.1 → 1.1.3

package/dist/es2019/plugins/table/transforms/merge.js

@@ -3,17 +3,16 @@ import { Selection } from 'prosemirror-state';
 import { TableMap } from '@atlaskit/editor-tables/table-map';
 import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
 import { findTable, getSelectionRect } from '@atlaskit/editor-tables/utils';
-import { setMeta } from './metadata'; // re-creates table node with merged cells
+import { setMeta } from './metadata';
 
+// re-creates table node with merged cells
 export function mergeCells(tr) {
   const {
     selection
   } = tr;
-
   if (!(selection instanceof CellSelection) || !canMergeCells(tr)) {
     return tr;
   }
-
   const rect = getSelectionRect(selection);
   const table = findTable(selection);
   const map = TableMap.get(table.node);
@@ -21,53 +20,45 @@ export function mergeCells(tr) {
   const selectedCells = map.cellsInRect(rect);
   let mergedCellPos;
   const rows = [];
-
   for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
     const rowCells = [];
     const row = table.node.child(rowIndex);
-
     for (let colIndex = 0; colIndex < map.width; colIndex++) {
       const cellPos = map.map[rowIndex * map.width + colIndex];
       const cell = table.node.nodeAt(cellPos);
-
       if (!cell || seen.indexOf(cellPos) > -1) {
         continue;
       }
+      seen.push(cellPos);
 
-      seen.push(cellPos); // merged cell
-
+      // merged cell
       if (colIndex === rect.left && rowIndex === rect.top) {
-        mergedCellPos = cellPos; // merge content of the selected cells, dropping empty cells
-
+        mergedCellPos = cellPos;
+        // merge content of the selected cells, dropping empty cells
         let content = isEmptyCell(cell) ? Fragment.empty : cell.content;
         const seenContent = [mergedCellPos];
-
         for (let i = rect.top; i < rect.bottom; i++) {
           for (let j = rect.left; j < rect.right; j++) {
             const pos = map.map[i * map.width + j];
-
             if (seenContent.indexOf(pos) === -1) {
               seenContent.push(pos);
               const copyCell = table.node.nodeAt(pos);
-
               if (copyCell && !isEmptyCell(copyCell)) {
                 content = content.append(copyCell.content);
               }
             }
           }
         }
-
         const rowspan = rect.bottom - rect.top;
-
         if (rowspan < 1) {
           return setMeta({
             type: 'MERGE_CELLS',
             problem: 'NEGATIVE_ROWSPAN'
           })(tr);
-        } // update colspan and rowspan of the merged cell to span the selection
-
-
-        const attrs = addColSpan({ ...cell.attrs,
+        }
+        // update colspan and rowspan of the merged cell to span the selection
+        const attrs = addColSpan({
+          ...cell.attrs,
           rowspan
         }, cell.attrs.colspan, rect.right - rect.left - cell.attrs.colspan);
         const newCell = content === Fragment.empty ? cell.type.createAndFill(attrs, content, cell.marks) : cell.type.createChecked(attrs, content, cell.marks);
@@ -78,7 +69,6 @@ export function mergeCells(tr) {
         rowCells.push(cell);
       }
     }
-
     if (rowCells.length) {
       rows.push(row.type.createChecked(row.attrs, rowCells, row.marks));
     } else {
@@ -87,56 +77,49 @@ export function mergeCells(tr) {
         const prevRow = rows[i];
         const cells = [];
         let rowChanged = false;
-
         for (let j = 0; j < prevRow.childCount; j++) {
           const cell = prevRow.child(j);
           const {
             rowspan
           } = cell.attrs;
-
           if (rowspan && rowspan + i - 1 >= rows.length) {
             rowChanged = true;
-
             if (rowspan < 2) {
               return setMeta({
                 type: 'MERGE_CELLS',
                 problem: 'NEGATIVE_ROWSPAN'
               })(tr);
             }
-
-            cells.push(cell.type.createChecked({ ...cell.attrs,
+            cells.push(cell.type.createChecked({
+              ...cell.attrs,
               rowspan: rowspan - 1
             }, cell.content, cell.marks));
           } else {
             cells.push(cell);
           }
         }
-
         if (rowChanged) {
           rows[i] = row.type.createChecked(prevRow.attrs, cells, prevRow.marks);
         }
       }
     }
-  } // empty tables? cancel merging like nothing happened
-
+  }
 
+  // empty tables? cancel merging like nothing happened
   if (!rows.length) {
     return setMeta({
       type: 'MERGE_CELLS',
       problem: 'EMPTY_TABLE'
     })(tr);
   }
-
   const newTable = table.node.type.createChecked(table.node.attrs, rows, table.node.marks);
   const fixedTable = removeEmptyColumns(newTable);
-
   if (fixedTable === null) {
     return setMeta({
       type: 'MERGE_CELLS',
       problem: 'REMOVE_EMPTY_COLUMNS'
     })(tr);
   }
-
   return setMeta({
     type: 'MERGE_CELLS'
   })(tr.replaceWith(table.pos, table.pos + table.node.nodeSize, fixedTable).setSelection(Selection.near(tr.doc.resolve((mergedCellPos || 0) + table.start))));
@@ -145,50 +128,39 @@ export function canMergeCells(tr) {
   const {
     selection
   } = tr;
-
   if (!(selection instanceof CellSelection) || selection.$anchorCell.pos === selection.$headCell.pos) {
     return false;
   }
-
   const rect = getSelectionRect(selection);
-
   if (!rect) {
     return false;
   }
-
   const table = selection.$anchorCell.node(-1);
   const map = TableMap.get(table);
-
   if (cellsOverlapRectangle(map, rect)) {
     return false;
   }
-
   return true;
 }
-
 function isEmptyCell(cell) {
   const {
     content
   } = cell;
   return content.childCount === 1 && content.firstChild && content.firstChild.isTextblock && content.firstChild.childCount === 0;
 }
-
 function addColSpan(attrs, pos, span = 1) {
-  const newAttrs = { ...attrs,
+  const newAttrs = {
+    ...attrs,
     colspan: (attrs.colspan || 1) + span
   };
-
   if (newAttrs.colwidth) {
     newAttrs.colwidth = newAttrs.colwidth.slice();
-
     for (let i = 0; i < span; i++) {
       newAttrs.colwidth.splice(pos, 0, 0);
     }
   }
-
   return newAttrs;
 }
-
 function cellsOverlapRectangle({
   width,
   height,
@@ -198,33 +170,27 @@ function cellsOverlapRectangle({
   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 true;
     }
-
     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 true;
     }
-
     indexTop++;
     indexBottom++;
   }
-
   return false;
-} // returns an array of numbers, each number indicates the minimum colSpan in each column
-
+}
 
+// returns an array of numbers, each number indicates the minimum colSpan in each column
 function getMinColSpans(table) {
   const map = TableMap.get(table);
   const minColspans = [];
-
   for (let colIndex = map.width - 1; colIndex >= 0; colIndex--) {
     const cellsPositions = map.cellsInRect({
       left: colIndex,
@@ -232,17 +198,15 @@ function getMinColSpans(table) {
       top: 0,
       bottom: map.height
     });
-
     if (cellsPositions.length) {
       const colspans = cellsPositions.map(cellPos => {
         const cell = table.nodeAt(cellPos);
-
         if (cell) {
           return cell.attrs.colspan;
         }
       });
-      const minColspan = Math.min(...colspans); // only care about the case when the next column is invisible
-
+      const minColspan = Math.min(...colspans);
+      // only care about the case when the next column is invisible
       if (!minColspans[colIndex + 1]) {
         minColspans[colIndex] = minColspan;
       } else {
@@ -250,42 +214,34 @@ function getMinColSpans(table) {
       }
     }
   }
-
   return minColspans;
 }
-
 export function removeEmptyColumns(table) {
   const map = TableMap.get(table);
   const minColSpans = getMinColSpans(table);
-
   if (!minColSpans.some(colspan => colspan > 1)) {
     return table;
   }
-
   const rows = [];
-
   for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
     const cellsByCols = {};
     const cols = Object.keys(minColSpans).map(Number);
-
     for (let idx in cols) {
       const colIndex = cols[idx];
       const cellPos = map.map[colIndex + rowIndex * map.width];
       const rect = map.findCell(cellPos);
       const cell = cellsByCols[rect.left] || table.nodeAt(cellPos);
-
       if (cell && rect.top === rowIndex) {
         if (minColSpans[colIndex] > 1) {
           const colspan = cell.attrs.colspan - minColSpans[colIndex] + 1;
-
           if (colspan < 1) {
             return null;
           }
-
           const {
             colwidth
           } = cell.attrs;
-          const newCell = cell.type.createChecked({ ...cell.attrs,
+          const newCell = cell.type.createChecked({
+            ...cell.attrs,
             colspan,
             colwidth: colwidth ? colwidth.slice(0, colspan) : null
           }, cell.content, cell.marks);
@@ -295,18 +251,14 @@ export function removeEmptyColumns(table) {
         }
       }
     }
-
     const rowCells = Object.keys(cellsByCols).map(col => cellsByCols[col]);
     const row = table.child(rowIndex);
-
     if (row) {
       rows.push(row.type.createChecked(row.attrs, rowCells, row.marks));
     }
   }
-
   if (!rows.length) {
     return null;
   }
-
   return table.type.createChecked(table.attrs, rows, table.marks);
 }

package/dist/es2019/plugins/table/transforms/metadata.js

@@ -1,11 +1,12 @@
 import { pluginKey } from '../pm-plugins/plugin-key';
-import { fireAnalytics } from './fix-tables'; // Set metadata on a ProseMirror transaction for debugging purposes in Synchrony
+import { fireAnalytics } from './fix-tables';
+
+// Set metadata on a ProseMirror transaction for debugging purposes in Synchrony
 
 export const setMeta = meta => tr => {
   if ('problem' in meta) {
     // Send analytics event whenever we encounter with a problem
     fireAnalytics(meta);
   }
-
   return tr.setMeta(pluginKey, meta);
 };

package/dist/es2019/plugins/table/transforms/replace-table.js

@@ -6,7 +6,6 @@ import { getSelectedTableInfo } from '../utils';
 export const replaceSelectedTable = (state, content, inputMethod, editorAnalyticsAPI) => {
   if (isTableSelected(state.selection)) {
     const table = findTable(state.selection);
-
     if (table) {
       const slice = typeof content === 'string' ? new Slice(Fragment.from(state.schema.text(content)), 0, 0) : content;
       let tr = state.tr.replace(table.pos, table.pos + table.node.nodeSize, slice);
@@ -28,6 +27,5 @@ export const replaceSelectedTable = (state, content, inputMethod, editorAnalytic
       return tr;
     }
   }
-
   return state.tr;
 };

package/dist/es2019/plugins/table/transforms/split.js

@@ -1,5 +1,4 @@
 import { TableMap } from '@atlaskit/editor-tables/table-map';
-
 /**
  * Helper to split all the cells in a range of columns
  * @param tr
@@ -10,63 +9,61 @@ import { TableMap } from '@atlaskit/editor-tables/table-map';
 export function splitCellsInColumns(tr, tablePos, columnStart, columnEnd) {
   let mapStart = tr.mapping.maps.length;
   const table = tr.doc.nodeAt(tablePos);
-
   if (!table) {
     return tr;
   }
-
   const tableStart = tr.doc.resolve(tablePos).start(1);
   const map = TableMap.get(table);
-
   for (let column = columnStart; column < columnEnd; column++) {
     for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
       const cellIndex = rowIndex * map.width + column;
-      const cellPos = map.map[cellIndex]; // Check if the cell is contained by another by another row/column
-
-      const hasMergedCellsBefore = column > 0 && map.map[cellIndex - 1] === cellPos || rowIndex > 0 && map.map[(rowIndex - 1) * map.width + column] === cellPos; // Check if the cell contains another row/column
+      const cellPos = map.map[cellIndex];
 
+      // Check if the cell is contained by another by another row/column
+      const hasMergedCellsBefore = column > 0 && map.map[cellIndex - 1] === cellPos || rowIndex > 0 && map.map[(rowIndex - 1) * map.width + column] === cellPos;
+      // Check if the cell contains another row/column
       const hasMergedCellsAfter = column < map.width - 1 && map.map[cellIndex + 1] === cellPos || rowIndex < map.height - 1 && map.map[(rowIndex + 1) * map.width + column] === cellPos;
-
       if (!hasMergedCellsBefore && hasMergedCellsAfter) {
         // Is a merged cell that start in this row/column
         const cellNode = table.nodeAt(cellPos);
-
         if (!cellNode) {
           continue;
         }
-
         const {
           colwidth,
           colspan = 1,
           rowspan = 1
         } = cellNode.attrs;
-        let mapping = tr.mapping.slice(mapStart); // Update current node with the simple colspan
+        let mapping = tr.mapping.slice(mapStart);
 
-        const baseAttrs = { ...cellNode.attrs,
+        // Update current node with the simple colspan
+        const baseAttrs = {
+          ...cellNode.attrs,
           colspan: 1,
           rowspan: 1
-        }; // Add the new cells
-
+        };
+        // Add the new cells
         for (let cellRowIndex = rowIndex; cellRowIndex < rowIndex + rowspan; cellRowIndex++) {
           for (let i = 0; i < colspan; i++) {
             let mapping = tr.mapping.slice(mapStart);
             const cellPos = map.positionAt(cellRowIndex, column + i, table);
-            tr.insert(mapping.map(cellPos + tableStart), cellNode.type.createAndFill({ ...baseAttrs,
+            tr.insert(mapping.map(cellPos + tableStart), cellNode.type.createAndFill({
+              ...baseAttrs,
               colwidth: colwidth ? [colwidth[i]] : undefined
             }));
           }
-        } // Delete the original cell
-
+        }
 
+        // Delete the original cell
         mapping = tr.mapping.slice(mapStart);
-        tr.delete(mapping.map(cellPos + tableStart), mapping.map(cellPos + tableStart + cellNode.nodeSize)); // Skip rows based on rowspan
+        tr.delete(mapping.map(cellPos + tableStart), mapping.map(cellPos + tableStart + cellNode.nodeSize));
 
+        // Skip rows based on rowspan
         if (rowspan && rowspan > 1) {
           rowIndex += rowspan - 1;
         }
       }
     }
   }
-
   return tr;
 }

package/dist/es2019/plugins/table/types.js

@@ -2,7 +2,6 @@ import { tableCellSelector, tableHeaderSelector, tablePrefixSelector } from '@at
 import { TableSharedCssClassName } from '@atlaskit/editor-common/styles';
 export const RESIZE_HANDLE_AREA_DECORATION_GAP = 30;
 export let TableDecorations;
-
 (function (TableDecorations) {
   TableDecorations["ALL_CONTROLS_HOVER"] = "CONTROLS_HOVER";
   TableDecorations["ROW_CONTROLS_HOVER"] = "ROW_CONTROLS_HOVER";
@@ -15,8 +14,8 @@ export let TableDecorations;
   TableDecorations["COLUMN_RESIZING_HANDLE_LINE"] = "COLUMN_RESIZING_HANDLE_LINE";
   TableDecorations["LAST_CELL_ELEMENT"] = "LAST_CELL_ELEMENT";
 })(TableDecorations || (TableDecorations = {}));
-
-export const TableCssClassName = { ...TableSharedCssClassName,
+export const TableCssClassName = {
+  ...TableSharedCssClassName,
   COLUMN_CONTROLS: `${tablePrefixSelector}-column-controls`,
   COLUMN_CONTROLS_DECORATIONS: `${tablePrefixSelector}-column-controls-decoration`,
   COLUMN_SELECTED: `${tablePrefixSelector}-column__selected`,
@@ -78,7 +77,6 @@ export const TableCssClassName = { ...TableSharedCssClassName,
   WITH_RESIZE_LINE_LAST_COLUMN: `${tablePrefixSelector}-column-resize-line-last-column`
 };
 export let ShadowEvent;
-
 (function (ShadowEvent) {
   ShadowEvent["SHOW_BEFORE_SHADOW"] = "showBeforeShadow";
   ShadowEvent["SHOW_AFTER_SHADOW"] = "showAfterShadow";

package/dist/es2019/plugins/table/ui/FloatingContextualButton/index.js

@@ -1,5 +1,4 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-
 /** @jsx jsx */
 import React from 'react';
 import { jsx } from '@emotion/react';
@@ -20,23 +19,21 @@ import { ErrorBoundary } from '@atlaskit/editor-common/error-boundary';
 export class FloatingContextualButtonInner extends React.Component {
   constructor(...args) {
     super(...args);
-
     _defineProperty(this, "handleClick", () => {
       const {
         state,
         dispatch
-      } = this.props.editorView; // Clicking outside the dropdown handles toggling the menu closed
+      } = this.props.editorView;
+      // Clicking outside the dropdown handles toggling the menu closed
       // (otherwise these two toggles combat each other).
       // In the event a user clicks the chevron button again
       // That will count as clicking outside the dropdown and
       // will be toggled appropriately
-
       if (!this.props.isContextualMenuOpen) {
         toggleContextualMenu()(state, dispatch);
       }
     });
   }
-
   render() {
     const {
       mountPoint,
@@ -49,16 +46,13 @@ export class FloatingContextualButtonInner extends React.Component {
       },
       dispatchAnalyticsEvent
     } = this.props; //  : Props & WrappedComponentProps
-
     const domAtPos = editorView.domAtPos.bind(editorView);
     let targetCellRef;
-
     try {
       targetCellRef = findDomRefAtPos(targetCellPosition, domAtPos);
     } catch (error) {
       // eslint-disable-next-line no-console
       console.warn(error);
-
       if (dispatchAnalyticsEvent) {
         const payload = {
           action: ACTION.ERRORED,
@@ -78,11 +72,9 @@ export class FloatingContextualButtonInner extends React.Component {
         dispatchAnalyticsEvent(payload);
       }
     }
-
     if (!targetCellRef || !(targetCellRef instanceof HTMLElement)) {
       return null;
     }
-
     const tableWrapper = closestElement(targetCellRef, `.${ClassName.TABLE_NODE_WRAPPER}`);
     const labelCellOptions = formatMessage(messages.cellOptions);
     const button = jsx("div", {
@@ -102,7 +94,6 @@ export class FloatingContextualButtonInner extends React.Component {
       "aria-label": labelCellOptions
     }));
     const parentSticky = targetCellRef.parentElement && targetCellRef.parentElement.className.indexOf('sticky') > -1;
-
     if (this.props.stickyHeader && parentSticky) {
       const pos = targetCellRef.getBoundingClientRect();
       return jsx("div", {
@@ -114,7 +105,6 @@ export class FloatingContextualButtonInner extends React.Component {
         }
       }, button);
     }
-
     return jsx(Popup, {
       alignX: "right",
       alignY: "start",
@@ -128,15 +118,11 @@ export class FloatingContextualButtonInner extends React.Component {
       zIndex: akEditorSmallZIndex
     }, button);
   }
-
   shouldComponentUpdate(nextProps) {
     return this.props.tableNode !== nextProps.tableNode || this.props.targetCellPosition !== nextProps.targetCellPosition || this.props.layout !== nextProps.layout || this.props.isContextualMenuOpen !== nextProps.isContextualMenuOpen || this.props.isNumberColumnEnabled !== nextProps.isNumberColumnEnabled || this.props.stickyHeader !== nextProps.stickyHeader;
   }
-
 }
-
 _defineProperty(FloatingContextualButtonInner, "displayName", 'FloatingContextualButton');
-
 const FloatingContextualButton = injectIntl(FloatingContextualButtonInner);
 export default function (props) {
   return jsx(ErrorBoundary, {