@atlaskit/editor-plugin-table 0.0.0 → 0.0.2

package/dist/esm/plugins/table/commands/collapse.js

@@ -0,0 +1,14 @@
+import { collapseSelectedTable } from '../utils/collapse';
+export var wrapTableInExpand = function wrapTableInExpand(state, dispatch) {
+  var collapseTr = collapseSelectedTable(state.tr);
+
+  if (!collapseTr) {
+    return false;
+  }
+
+  if (dispatch) {
+    dispatch(collapseTr);
+  }
+
+  return true;
+};

package/dist/esm/plugins/table/commands/go-to-next-cell.js

@@ -0,0 +1,50 @@
+// #region Constants
+import { findTable, goToNextCell as baseGotoNextCell } from '@atlaskit/editor-tables/utils';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { findParentNodeOfType } from 'prosemirror-utils';
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { insertRowWithAnalytics } from '../commands-with-analytics';
+var TAB_FORWARD_DIRECTION = 1;
+var TAB_BACKWARD_DIRECTION = -1;
+export var goToNextCell = function goToNextCell(editorAnalyticsAPI) {
+  return function (direction) {
+    return function (state, dispatch) {
+      var table = findTable(state.selection);
+
+      if (!table) {
+        return false;
+      }
+
+      var map = TableMap.get(table.node);
+      var _state$schema$nodes = state.schema.nodes,
+          tableCell = _state$schema$nodes.tableCell,
+          tableHeader = _state$schema$nodes.tableHeader;
+      var cell = findParentNodeOfType([tableCell, tableHeader])(state.selection);
+      var firstCellPos = map.positionAt(0, 0, table.node) + table.start;
+      var lastCellPos = map.positionAt(map.height - 1, map.width - 1, table.node) + table.start; // when tabbing backwards at first cell (top left), insert row at the start of table
+
+      if (firstCellPos === cell.pos && direction === TAB_BACKWARD_DIRECTION) {
+        insertRowWithAnalytics(editorAnalyticsAPI)(INPUT_METHOD.KEYBOARD, {
+          index: 0,
+          moveCursorToInsertedRow: true
+        })(state, dispatch);
+        return true;
+      } // when tabbing forwards at last cell (bottom right), insert row at the end of table
+
+
+      if (lastCellPos === cell.pos && direction === TAB_FORWARD_DIRECTION) {
+        insertRowWithAnalytics(editorAnalyticsAPI)(INPUT_METHOD.KEYBOARD, {
+          index: map.height,
+          moveCursorToInsertedRow: true
+        })(state, dispatch);
+        return true;
+      }
+
+      if (dispatch) {
+        return baseGotoNextCell(direction)(state, dispatch);
+      }
+
+      return true;
+    };
+  };
+};

package/dist/esm/plugins/table/commands/hover.js

@@ -0,0 +1,149 @@
+// #region Imports
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { findTable, getCellsInColumn, getCellsInRow } from '@atlaskit/editor-tables/utils';
+import { createCommand } from '../pm-plugins/plugin-factory';
+import { TableDecorations } from '../types';
+import { createCellHoverDecoration, createColumnLineResize, createControlsHoverDecoration, getMergedCellsPositions, updatePluginStateDecorations } from '../utils'; // #endregion
+// #region Utils
+
+var makeArray = function makeArray(n) {
+  return Array.from(Array(n).keys());
+}; // #endregion
+// #region Commands
+
+
+export var hoverMergedCells = function hoverMergedCells() {
+  return createCommand(function (state) {
+    var mergedCellsPositions = getMergedCellsPositions(state.tr);
+
+    if (!mergedCellsPositions.length) {
+      return false;
+    }
+
+    var table = findTable(state.tr.selection);
+
+    if (!table) {
+      return false;
+    }
+
+    var mergedCells = mergedCellsPositions.map(function (pos) {
+      return {
+        pos: pos + table.start,
+        start: pos + table.start + 1,
+        node: table.node.nodeAt(pos)
+      };
+    });
+    var decorations = createCellHoverDecoration(mergedCells, 'warning');
+    return {
+      type: 'HOVER_CELLS',
+      data: {
+        decorationSet: updatePluginStateDecorations(state, decorations, TableDecorations.CELL_CONTROLS_HOVER)
+      }
+    };
+  }, function (tr) {
+    return tr.setMeta('addToHistory', false);
+  });
+};
+export var hoverColumns = function hoverColumns(hoveredColumns, isInDanger) {
+  return createCommand(function (state) {
+    var cells = getCellsInColumn(hoveredColumns)(state.selection);
+
+    if (!cells) {
+      return false;
+    }
+
+    var decorations = createControlsHoverDecoration(cells, 'column', isInDanger);
+    return {
+      type: 'HOVER_COLUMNS',
+      data: {
+        decorationSet: updatePluginStateDecorations(state, decorations, TableDecorations.COLUMN_CONTROLS_HOVER),
+        hoveredColumns: hoveredColumns,
+        isInDanger: isInDanger
+      }
+    };
+  }, function (tr) {
+    return tr.setMeta('addToHistory', false);
+  });
+};
+export var hoverRows = function hoverRows(hoveredRows, isInDanger) {
+  return createCommand(function (state) {
+    var cells = getCellsInRow(hoveredRows)(state.selection);
+
+    if (!cells) {
+      return false;
+    }
+
+    var decorations = createControlsHoverDecoration(cells, 'row', isInDanger);
+    return {
+      type: 'HOVER_ROWS',
+      data: {
+        decorationSet: updatePluginStateDecorations(state, decorations, TableDecorations.ROW_CONTROLS_HOVER),
+        hoveredRows: hoveredRows,
+        isInDanger: isInDanger
+      }
+    };
+  }, function (tr) {
+    return tr.setMeta('addToHistory', false);
+  });
+};
+export var hoverTable = function hoverTable(isInDanger, isSelected) {
+  return createCommand(function (state) {
+    var table = findTable(state.selection);
+
+    if (!table) {
+      return false;
+    }
+
+    var map = TableMap.get(table.node);
+    var hoveredColumns = makeArray(map.width);
+    var hoveredRows = makeArray(map.height);
+    var cells = getCellsInRow(hoveredRows)(state.selection);
+
+    if (!cells) {
+      return false;
+    }
+
+    var decorations = createControlsHoverDecoration(cells, 'table', isInDanger, isSelected);
+    return {
+      type: 'HOVER_TABLE',
+      data: {
+        decorationSet: updatePluginStateDecorations(state, decorations, TableDecorations.TABLE_CONTROLS_HOVER),
+        hoveredColumns: hoveredColumns,
+        hoveredRows: hoveredRows,
+        isInDanger: isInDanger
+      }
+    };
+  }, function (tr) {
+    return tr.setMeta('addToHistory', false);
+  });
+};
+export var clearHoverSelection = function clearHoverSelection() {
+  return createCommand(function (state) {
+    return {
+      type: 'CLEAR_HOVER_SELECTION',
+      data: {
+        decorationSet: updatePluginStateDecorations(state, [], TableDecorations.ALL_CONTROLS_HOVER)
+      }
+    };
+  });
+};
+export var showResizeHandleLine = function showResizeHandleLine(cellColumnPositioning) {
+  return createCommand(function (state) {
+    return {
+      type: 'SHOW_RESIZE_HANDLE_LINE',
+      data: {
+        decorationSet: updatePluginStateDecorations(state, createColumnLineResize(state.selection, cellColumnPositioning), TableDecorations.COLUMN_RESIZING_HANDLE_LINE)
+      }
+    };
+  });
+};
+export var hideResizeHandleLine = function hideResizeHandleLine() {
+  return createCommand(function (state) {
+    return {
+      type: 'HIDE_RESIZE_HANDLE_LINE',
+      data: {
+        decorationSet: updatePluginStateDecorations(state, [], TableDecorations.COLUMN_RESIZING_HANDLE_LINE)
+      }
+    };
+  });
+}; // #endregion

package/dist/esm/plugins/table/commands/index.js

@@ -0,0 +1,7 @@
+export { hoverColumns, hoverRows, hoverTable, hoverMergedCells, clearHoverSelection, showResizeHandleLine, hideResizeHandleLine } from './hover';
+export { insertColumn, insertRow, createTable } from './insert';
+export { getNextLayout, toggleContextualMenu, toggleHeaderColumn, toggleHeaderRow, toggleNumberColumn, toggleTableLayout } from './toggle';
+export { clearMultipleCells } from './clear';
+export { autoSizeTable, convertFirstRowToHeader, deleteTable, hideInsertColumnOrRowButton, moveCursorBackward, selectColumn, selectRow, setCellAttr, setEditorFocus, setMultipleCellAttrs, setTableRef, showInsertColumnButton, showInsertRowButton, transformSliceToAddTableHeaders, triggerUnlessTableHeader, addBoldInEmptyHeaderCells, addResizeHandleDecorations } from './misc';
+export { sortByColumn } from './sort';
+export { goToNextCell } from './go-to-next-cell';

package/dist/esm/plugins/table/commands/insert.js

@@ -0,0 +1,153 @@
+// #region Imports
+import { Selection } from 'prosemirror-state';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { addColumnAt as addColumnAtPMUtils, addRowAt, createTable as createTableNode, findTable, selectedRect } from '@atlaskit/editor-tables/utils';
+import { safeInsert } from 'prosemirror-utils';
+import { AddColumnStep } from '@atlaskit/adf-schema/steps';
+import { checkIfHeaderRowEnabled, copyPreviousRow } from '../utils';
+import { getAllowAddColumnCustomStep } from '../utils/get-allow-add-column-custom-step';
+import { rescaleColumns } from '../transforms/column-width';
+
+// #endregion
+function addColumnAtCustomStep(column) {
+  return function (tr) {
+    var table = findTable(tr.selection);
+
+    if (table) {
+      return tr.step(AddColumnStep.create(tr.doc, table.pos, column));
+    }
+
+    return tr;
+  };
+}
+
+export function addColumnAt(getEditorContainerWidth) {
+  return function (column) {
+    var allowAddColumnCustomStep = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var view = arguments.length > 2 ? arguments[2] : undefined;
+    return function (tr) {
+      var updatedTr = tr;
+
+      if (allowAddColumnCustomStep) {
+        updatedTr = addColumnAtCustomStep(column)(updatedTr);
+      } else {
+        updatedTr = addColumnAtPMUtils(column)(updatedTr);
+      }
+
+      var table = findTable(updatedTr.selection);
+
+      if (table) {
+        // [ED-8288] Update colwidths manually to avoid multiple dispatch in TableComponent
+        updatedTr = rescaleColumns(getEditorContainerWidth)(table, view)(updatedTr);
+      }
+
+      return updatedTr;
+    };
+  };
+} // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
+// Command to add a column before the column with the selection.
+
+export var addColumnBefore = function addColumnBefore(getEditorContainerWidth) {
+  return function (state, dispatch, view) {
+    var table = findTable(state.selection);
+
+    if (!table) {
+      return false;
+    }
+
+    if (dispatch) {
+      var rect = selectedRect(state);
+      dispatch(addColumnAt(getEditorContainerWidth)(rect.left, getAllowAddColumnCustomStep(state), view)(state.tr));
+    }
+
+    return true;
+  };
+}; // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
+// Command to add a column after the column with the selection.
+
+export var addColumnAfter = function addColumnAfter(getEditorContainerWidth) {
+  return function (state, dispatch, view) {
+    var table = findTable(state.selection);
+
+    if (!table) {
+      return false;
+    }
+
+    if (dispatch) {
+      var rect = selectedRect(state);
+      dispatch(addColumnAt(getEditorContainerWidth)(rect.right, getAllowAddColumnCustomStep(state), view)(state.tr));
+    }
+
+    return true;
+  };
+}; // #region Commands
+
+export var insertColumn = function insertColumn(getEditorContainerWidth) {
+  return function (column) {
+    return function (state, dispatch, view) {
+      var tr = addColumnAt(getEditorContainerWidth)(column, getAllowAddColumnCustomStep(state), view)(state.tr);
+      var table = findTable(tr.selection);
+
+      if (!table) {
+        return false;
+      } // move the cursor to the newly created column
+
+
+      var pos = TableMap.get(table.node).positionAt(0, column, table.node);
+
+      if (dispatch) {
+        dispatch(tr.setSelection(Selection.near(tr.doc.resolve(table.start + pos))));
+      }
+
+      return true;
+    };
+  };
+};
+export var insertRow = function insertRow(row, moveCursorToTheNewRow) {
+  return function (state, dispatch) {
+    // Don't clone the header row
+    var headerRowEnabled = checkIfHeaderRowEnabled(state.selection);
+    var clonePreviousRow = headerRowEnabled && row > 1 || !headerRowEnabled && row > 0; // When the table have header row
+    // we should not add row on the position zero
+
+    if (row === 0 && headerRowEnabled) {
+      return false;
+    }
+
+    var tr = clonePreviousRow ? copyPreviousRow(state.schema)(row)(state.tr) : addRowAt(row)(state.tr);
+    var table = findTable(tr.selection);
+
+    if (!table) {
+      return false;
+    }
+
+    if (dispatch) {
+      var selection = state.selection;
+
+      if (moveCursorToTheNewRow) {
+        // move the cursor to the newly created row
+        var pos = TableMap.get(table.node).positionAt(row, 0, table.node);
+        tr.setSelection(Selection.near(tr.doc.resolve(table.start + pos)));
+      } else {
+        tr.setSelection(selection.map(tr.doc, tr.mapping));
+      }
+
+      dispatch(tr);
+    }
+
+    return true;
+  };
+};
+export var createTable = function createTable() {
+  return function (state, dispatch) {
+    var table = createTableNode({
+      schema: state.schema
+    });
+
+    if (dispatch) {
+      dispatch(safeInsert(table)(state.tr).scrollIntoView());
+    }
+
+    return true;
+  };
+}; // #endregion