@atlaskit/editor-core 173.0.1 → 175.0.0

package/dist/es2019/plugins/table/pm-plugins/table-local-id.js

@@ -1,201 +0,0 @@
-/**
- * A plugin for ensuring tables always have unique local IDs, and to
- * preserve/not regenerate them when they are being cut and paste around the
- * document.
- *
- * More broadly, this plugin should be generalised so it can solve this ‘unique
- * id’ problem across the codebase for any node, but for now this will live on
- * its own solving only for tables.
- *
- * TODO: https://product-fabric.atlassian.net/browse/ED-12714
- *
- */
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { PluginKey } from 'prosemirror-state';
-import rafSchedule from 'raf-schd';
-import { uuid } from '@atlaskit/adf-schema';
-import { stepAddsOneOf } from '../../../utils/step';
-const pluginKey = new PluginKey('tableLocalIdPlugin');
-
-const getPluginState = state => state && pluginKey.getState(state);
-/**
- * Traverses a transaction's steps to see if we're inserting any tables
- */
-
-
-const checkIsAddingTable = (transaction, nodeType) => {
-  return transaction.steps.some(step => stepAddsOneOf(step, new Set([nodeType])));
-};
-/**
- * Ensures uniqueness of `localId`s on tables being created or edited
- */
-
-
-const createPlugin = dispatch => new SafePlugin({
-  key: pluginKey,
-  state: {
-    init() {
-      return {
-        parsedForLocalIds: false
-      };
-    },
-
-    apply(tr, pluginState) {
-      const meta = tr.getMeta(pluginKey);
-
-      if (meta) {
-        const keys = Object.keys(meta);
-        const changed = keys.some(key => {
-          return pluginState[key] !== meta[key];
-        });
-
-        if (changed) {
-          const newState = { ...pluginState,
-            ...meta
-          };
-          dispatch(pluginKey, newState);
-          return newState;
-        }
-      }
-
-      return pluginState;
-    }
-
-  },
-  view: () => {
-    return {
-      /**
-       * Utilise the update cycle for _one_ scan through an initial doc
-       * to ensure existing tables without IDs get them when this plugin is
-       * enabled.
-       *
-       * This entire block can be skipped if we simply remove the `checkIsAddingTable`
-       * check in appendTransaction, but that comes with 2 cons:
-       *
-       * 1. require a transaction before we actually add the local IDs
-       * 2. ever slightly more unncessary checks
-       *
-       * Finally, this never happens in practice when utilising this in
-       * confluence, as the collab/synchrony initialisation process will
-       * trigger a transaction which adds tables, and thus this plugin will
-       * add/dedupe the necessary IDs. But general usage of the editor
-       * without collab should still solve for IDs.
-       */
-      update(editorView) {
-        const {
-          state
-        } = editorView;
-        const pluginState = getPluginState(state);
-
-        if (!pluginState) {
-          return;
-        }
-
-        const parsed = pluginState.parsedForLocalIds;
-
-        if (parsed) {
-          return;
-        }
-
-        const {
-          table
-        } = state.schema.nodes;
-        rafSchedule(() => {
-          const tr = state.tr;
-          let tableIdWasAdded = false;
-          editorView.state.doc.descendants((node, pos) => {
-            const isTable = node.type === table;
-            const localId = node.attrs.localId;
-
-            if (isTable && !localId) {
-              tableIdWasAdded = true;
-              tr.setNodeMarkup(pos, undefined, { ...node.attrs,
-                localId: uuid.generate()
-              });
-              return false;
-            }
-            /**
-             * Otherwise continue traversing, we can encounter tables nested in
-             * expands/bodiedExtensions
-             */
-
-
-            return true;
-          });
-
-          if (tableIdWasAdded) {
-            tr.setMeta('addToHistory', false);
-            editorView.dispatch(tr);
-          }
-        })();
-        editorView.dispatch(state.tr.setMeta(pluginKey, {
-          parsedForLocalIds: true
-        }));
-      }
-
-    };
-  },
-  appendTransaction: (transactions, _oldState, newState) => {
-    let modified = false;
-    const tr = newState.tr;
-    const {
-      table
-    } = newState.schema.nodes;
-    const idsObserved = new Set();
-    transactions.forEach(transaction => {
-      if (!transaction.docChanged) {
-        return;
-      } // Don't interfere with cut as it clashes with fixTables & we don't need
-      // to handle any extra cut cases in this plugin
-
-
-      const uiEvent = transaction.getMeta('uiEvent');
-
-      if (uiEvent === 'cut') {
-        return;
-      }
-      /** Check if we're actually inserting a table, otherwise we can ignore this tr */
-
-
-      const isAddingTable = checkIsAddingTable(transaction, table);
-
-      if (!isAddingTable) {
-        return;
-      } // Can't simply look at changed nodes, as we could be adding a table
-
-
-      newState.doc.descendants((node, pos) => {
-        const isTable = node.type === table;
-        const localId = node.attrs.localId; // Dealing with a table - make sure it's a unique ID
-
-        if (isTable) {
-          if (localId && !idsObserved.has(localId)) {
-            idsObserved.add(localId); // Also add a localId if it happens to not have one,
-          } else if (!localId || idsObserved.has(localId)) {
-            modified = true;
-            tr.setNodeMarkup(pos, undefined, { ...node.attrs,
-              localId: uuid.generate()
-            });
-          }
-
-          return false;
-        }
-        /**
-         * Otherwise continue traversing, we can encounter tables nested in
-         * expands/bodiedExtensions
-         */
-
-
-        return true;
-      });
-    });
-
-    if (modified) {
-      return tr;
-    }
-
-    return;
-  }
-});
-
-export { createPlugin };

package/dist/es2019/plugins/table/pm-plugins/table-resizing/commands.js

@@ -1,109 +0,0 @@
-import { isTableSelected } from '@atlaskit/editor-tables/utils';
-import { updateColumnWidths } from '../../transforms';
-import { createCommand, getPluginState } from './plugin-factory';
-import { evenAllColumnsWidths, hasTableBeenResized, isClickNear, insertColgroupFromNode as recreateResizeColsByNode, scale, scaleWithParent } from './utils';
-// Scale the table to meet new requirements (col, layout change etc)
-export const scaleTable = (tableRef, options, domAtPos) => (state, dispatch) => {
-  if (!tableRef) {
-    return false;
-  }
-
-  const {
-    node,
-    start,
-    parentWidth
-  } = options; // If a table has not been resized yet, columns should be auto.
-
-  if (hasTableBeenResized(node) === false) {
-    // If its not a re-sized table, we still want to re-create cols
-    // To force reflow of columns upon delete.
-    recreateResizeColsByNode(tableRef, node);
-    return false;
-  }
-
-  let resizeState;
-
-  if (parentWidth) {
-    resizeState = scaleWithParent(tableRef, parentWidth, node, start, domAtPos);
-  } else {
-    resizeState = scale(tableRef, options, domAtPos);
-  }
-
-  if (resizeState) {
-    let {
-      tr
-    } = state;
-    tr = updateColumnWidths(resizeState, node, start)(tr);
-
-    if (tr.docChanged && dispatch) {
-      tr.setMeta('scrollIntoView', false); // TODO: ED-8995
-      // We need to do this check to reduce the number of race conditions when working with tables.
-      // This metadata is been used in the sendTransaction function in the Collab plugin
-
-      tr.setMeta('scaleTable', true);
-      dispatch(tr);
-      return true;
-    }
-  }
-
-  return false;
-};
-export const evenColumns = ({
-  resizeState,
-  table,
-  start,
-  event
-}) => (state, dispatch) => {
-  if (!isTableSelected(state.selection)) {
-    return false;
-  } // double click detection logic
-  // Note: ProseMirror's handleDoubleClick doesn't quite work with DOM mousedown event handler
-
-
-  const {
-    lastClick
-  } = getPluginState(state);
-  const now = Date.now();
-
-  if (lastClick && now - lastClick.time < 500 && isClickNear(event, lastClick)) {
-    const newState = evenAllColumnsWidths(resizeState);
-    setLastClick(null, tr => updateColumnWidths(newState, table, start)(tr))(state, dispatch);
-    return true;
-  }
-
-  setLastClick({
-    x: event.clientX,
-    y: event.clientY,
-    time: now
-  })(state, dispatch);
-  return false;
-};
-export const distributeColumnsWidths = (newResizeState, table) => (state, dispatch) => {
-  if (dispatch) {
-    const tr = updateColumnWidths(newResizeState, table.node, table.start)(state.tr);
-    stopResizing(tr)(state, dispatch);
-  }
-
-  return true;
-};
-export const setResizeHandlePos = resizeHandlePos => createCommand({
-  type: 'SET_RESIZE_HANDLE_POSITION',
-  data: {
-    resizeHandlePos
-  }
-});
-export const stopResizing = tr => createCommand({
-  type: 'STOP_RESIZING'
-}, originalTr => (tr || originalTr).setMeta('scrollIntoView', false));
-export const setDragging = (dragging, tr) => createCommand({
-  type: 'SET_DRAGGING',
-  data: {
-    dragging
-  }
-}, originalTr => tr || originalTr);
-export const setLastClick = (lastClick, transform) => createCommand({
-  type: 'SET_LAST_CLICK',
-  data: {
-    lastClick
-  }
-}, transform);

package/dist/es2019/plugins/table/pm-plugins/table-resizing/event-handlers.js

@@ -1,176 +0,0 @@
-import { TableMap } from '@atlaskit/editor-tables/table-map';
-import { getSelectionRect } from '@atlaskit/editor-tables/utils';
-import { tableCellMinWidth } from '@atlaskit/editor-common/styles';
-import { akEditorTableNumberColumnWidth } from '@atlaskit/editor-shared-styles';
-import { getParentNodeWidth } from '@atlaskit/editor-common/node-width';
-import { pluginKey as editorDisabledPluginKey } from '../../../editor-disabled';
-import { updateColumnWidths } from '../../transforms';
-import { getSelectedColumnIndexes, updateResizeHandles } from '../../utils';
-import { evenColumns, setDragging, stopResizing } from './commands';
-import { getPluginState } from './plugin-factory';
-import { currentColWidth, getLayoutSize, getResizeState, pointsAtCell, resizeColumn, updateControls } from './utils';
-import { ACTION_SUBJECT, EVENT_TYPE, TABLE_ACTION } from '@atlaskit/editor-common/analytics';
-export const handleMouseDown = (view, event, localResizeHandlePos, getEditorContainerWidth, getEditorFeatureFlags, editorAnalyticsAPI) => {
-  const {
-    state,
-    dispatch
-  } = view;
-  const {
-    editorDisabled
-  } = editorDisabledPluginKey.getState(state);
-  const domAtPos = view.domAtPos.bind(view);
-
-  if (editorDisabled || localResizeHandlePos === null || !pointsAtCell(state.doc.resolve(localResizeHandlePos))) {
-    return false;
-  }
-
-  event.preventDefault();
-  const mouseDownTime = event.timeStamp;
-  const cell = state.doc.nodeAt(localResizeHandlePos);
-  const $cell = state.doc.resolve(localResizeHandlePos);
-  const originalTable = $cell.node(-1);
-  const start = $cell.start(-1);
-  let dom = domAtPos(start).node;
-
-  if (dom && dom.nodeName !== 'TABLE') {
-    dom = dom.closest('table');
-  }
-
-  const containerWidth = getEditorContainerWidth();
-  const parentWidth = getParentNodeWidth(start, state, containerWidth);
-  let maxSize = parentWidth || getLayoutSize(dom.getAttribute('data-layout'), containerWidth.width, {});
-
-  if (originalTable.attrs.isNumberColumnEnabled) {
-    maxSize -= akEditorTableNumberColumnWidth;
-  }
-
-  const resizeState = getResizeState({
-    minWidth: tableCellMinWidth,
-    maxSize,
-    table: originalTable,
-    tableRef: dom,
-    start,
-    domAtPos
-  });
-
-  if (evenColumns({
-    resizeState,
-    table: originalTable,
-    start,
-    event
-  })(state, dispatch)) {
-    finish(event);
-    return true;
-  }
-
-  const width = currentColWidth(view, localResizeHandlePos, cell.attrs);
-  setDragging({
-    startX: event.clientX,
-    startWidth: width
-  })(state, dispatch);
-
-  function finish(event) {
-    window.removeEventListener('mouseup', finish);
-    window.removeEventListener('mousemove', move);
-    const {
-      clientX
-    } = event;
-    const {
-      state,
-      dispatch
-    } = view;
-    const {
-      dragging,
-      resizeHandlePos
-    } = getPluginState(state);
-
-    if (resizeHandlePos === null) {
-      return stopResizing()(state, dispatch);
-    }
-
-    if (!pointsAtCell(state.doc.resolve(resizeHandlePos))) {
-      return;
-    } // resizeHandlePos could be remapped via a collab change.
-    // Fetch a fresh reference of the table.
-
-
-    const $cell = state.doc.resolve(resizeHandlePos);
-    const start = $cell.start(-1);
-    const table = $cell.node(-1); // If we let go in the same place we started, dont need to do anything.
-
-    if (dragging && clientX === dragging.startX) {
-      return stopResizing()(state, dispatch);
-    }
-
-    let {
-      tr
-    } = state;
-
-    if (dragging) {
-      const {
-        startX
-      } = dragging; // If the table has changed (via collab for example) don't apply column widths
-      // For example, if a table col is deleted we won't be able to reliably remap the new widths
-      // There may be a more elegant solution to this, to avoid a jarring experience.
-
-      if (table.eq(originalTable)) {
-        const map = TableMap.get(table);
-        const colIndex = map.colCount($cell.pos - start) + ($cell.nodeAfter ? $cell.nodeAfter.attrs.colspan : 1) - 1;
-        const selectionRect = getSelectionRect(state.selection);
-        const selectedColumns = selectionRect ? getSelectedColumnIndexes(selectionRect) : []; // only selected (or selected - 1) columns should be distributed
-
-        const resizingSelectedColumns = selectedColumns.indexOf(colIndex) > -1 || selectedColumns.indexOf(colIndex + 1) > -1;
-        const newResizeState = resizeColumn(resizeState, colIndex, clientX - startX, dom, resizingSelectedColumns ? selectedColumns : undefined);
-        tr = updateColumnWidths(newResizeState, table, start)(tr);
-
-        if (colIndex === map.width - 1) {
-          const mouseUpTime = event.timeStamp;
-          editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
-            action: TABLE_ACTION.ATTEMPTED_TABLE_WIDTH_CHANGE,
-            actionSubject: ACTION_SUBJECT.TABLE,
-            actionSubjectId: null,
-            attributes: {
-              type: 'table-border',
-              position: 'right',
-              duration: mouseUpTime - mouseDownTime,
-              delta: Math.abs(clientX - dragging.startX)
-            },
-            eventType: EVENT_TYPE.UI
-          })(tr);
-        }
-      }
-
-      return stopResizing(tr)(state, dispatch);
-    }
-  }
-
-  function move(event) {
-    const {
-      clientX,
-      which
-    } = event;
-    const {
-      state
-    } = view;
-    const {
-      dragging,
-      resizeHandlePos
-    } = getPluginState(state);
-
-    if (!which || !dragging || resizeHandlePos === null || !pointsAtCell(state.doc.resolve(resizeHandlePos))) {
-      return finish(event);
-    }
-
-    const $cell = state.doc.resolve(resizeHandlePos);
-    const table = $cell.node(-1);
-    const map = TableMap.get(table);
-    const colIndex = map.colCount($cell.pos - $cell.start(-1)) + $cell.nodeAfter.attrs.colspan - 1;
-    resizeColumn(resizeState, colIndex, clientX - dragging.startX, dom);
-    updateControls(getEditorFeatureFlags)(state);
-    updateResizeHandles(dom);
-  }
-
-  window.addEventListener('mouseup', finish);
-  window.addEventListener('mousemove', move);
-  return true;
-};

package/dist/es2019/plugins/table/pm-plugins/table-resizing/index.js

@@ -1,3 +0,0 @@
-export { createPlugin } from './plugin';
-export { scaleTable } from './commands';
-export { pluginKey } from './plugin-key';

package/dist/es2019/plugins/table/pm-plugins/table-resizing/plugin-factory.js

@@ -1,20 +0,0 @@
-import { pluginFactory } from '../../../../utils/plugin-state-factory';
-import { pluginKey } from './plugin-key';
-import reducer from './reducer';
-
-function mapping(tr, pluginState) {
-  if (pluginState && pluginState.resizeHandlePos !== null) {
-    return { ...pluginState,
-      resizeHandlePos: tr.mapping.map(pluginState.resizeHandlePos)
-    };
-  }
-
-  return pluginState;
-}
-
-const factory = pluginFactory(pluginKey, reducer, {
-  mapping
-});
-export const createCommand = factory.createCommand;
-export const createPluginState = factory.createPluginState;
-export const getPluginState = factory.getPluginState;

package/dist/es2019/plugins/table/pm-plugins/table-resizing/plugin-key.js

@@ -1,2 +0,0 @@
-import { PluginKey } from 'prosemirror-state';
-export const pluginKey = new PluginKey('tableFlexiColumnResizing');

package/dist/es2019/plugins/table/pm-plugins/table-resizing/plugin.js

@@ -1,58 +0,0 @@
-import classnames from 'classnames';
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { TableCssClassName as ClassName } from '../../types';
-import { setResizeHandlePos } from './commands';
-import { handleMouseDown } from './event-handlers';
-import { createPluginState, getPluginState } from './plugin-factory';
-import { pluginKey } from './plugin-key';
-import { getResizeCellPos } from './utils';
-export function createPlugin(dispatch, {
-  lastColumnResizable = true
-}, getEditorContainerWidth, getEditorFeatureFlags, editorAnalyticsAPI) {
-  return new SafePlugin({
-    key: pluginKey,
-    state: createPluginState(dispatch, {
-      lastColumnResizable,
-      resizeHandlePos: null,
-      dragging: null,
-      lastClick: null
-    }),
-    props: {
-      attributes(state) {
-        const pluginState = getPluginState(state);
-        return {
-          class: classnames(ClassName.RESIZING_PLUGIN, {
-            [ClassName.RESIZE_CURSOR]: pluginState.resizeHandlePos !== null,
-            [ClassName.IS_RESIZING]: !!pluginState.dragging
-          })
-        };
-      },
-
-      handleDOMEvents: {
-        mousedown(view, event) {
-          const {
-            state
-          } = view;
-          const resizeHandlePos = // we're setting `resizeHandlePos` via command in unit tests
-          getPluginState(state).resizeHandlePos || getResizeCellPos(view, event, lastColumnResizable);
-          const {
-            dragging
-          } = getPluginState(state);
-
-          if (resizeHandlePos !== null && !dragging) {
-            if (handleMouseDown(view, event, resizeHandlePos, getEditorContainerWidth, getEditorFeatureFlags, editorAnalyticsAPI)) {
-              const {
-                state,
-                dispatch
-              } = view;
-              return setResizeHandlePos(resizeHandlePos)(state, dispatch);
-            }
-          }
-
-          return false;
-        }
-
-      }
-    }
-  });
-}

package/dist/es2019/plugins/table/pm-plugins/table-resizing/reducer.js

@@ -1,31 +0,0 @@
-export default ((pluginState, action) => {
-  switch (action.type) {
-    case 'STOP_RESIZING':
-      return { ...pluginState,
-        resizeHandlePos: null,
-        dragging: null
-      };
-
-    case 'SET_RESIZE_HANDLE_POSITION':
-      return { ...pluginState,
-        resizeHandlePos: action.data.resizeHandlePos
-      };
-
-    case 'SET_DRAGGING':
-      return { ...pluginState,
-        dragging: action.data.dragging
-      };
-
-    case 'SET_LAST_CLICK':
-      const {
-        lastClick
-      } = action.data;
-      return { ...pluginState,
-        lastClick,
-        resizeHandlePos: lastClick ? pluginState.resizeHandlePos : null
-      };
-
-    default:
-      return pluginState;
-  }
-});

package/dist/es2019/plugins/table/pm-plugins/table-resizing/utils/colgroup.js

@@ -1,45 +0,0 @@
-import { DOMSerializer } from 'prosemirror-model';
-import { getFragmentBackingArray } from '../../../../../utils/slice';
-export const generateColgroup = table => {
-  const cols = [];
-  table.content.firstChild.content.forEach(cell => {
-    const colspan = cell.attrs.colspan || 1;
-
-    if (Array.isArray(cell.attrs.colwidth)) {
-      // We slice here to guard against our colwidth array having more entries
-      // Than the we actually span. We'll patch the document at a later point.
-      cell.attrs.colwidth.slice(0, colspan).forEach(width => {
-        cols.push(['col', width ? {
-          style: `width: ${width}px;`
-        } : {}]);
-      });
-    } else {
-      // When we have merged cells on the first row (firstChild),
-      // We want to ensure we're creating the appropriate amount of
-      // cols the table still has.
-      cols.push(...Array.from({
-        length: colspan
-      }, _ => ['col', {}]));
-    }
-  });
-  return cols;
-};
-export const insertColgroupFromNode = (tableRef, table) => {
-  let colgroup = tableRef.querySelector('colgroup');
-
-  if (colgroup) {
-    tableRef.removeChild(colgroup);
-  }
-
-  colgroup = renderColgroupFromNode(table);
-  tableRef.insertBefore(colgroup, tableRef.firstChild);
-  return colgroup.children;
-};
-export const hasTableBeenResized = table => {
-  return !!getFragmentBackingArray(table.content.firstChild.content).find(cell => cell.attrs.colwidth);
-};
-
-function renderColgroupFromNode(table) {
-  const rendered = DOMSerializer.renderSpec(document, ['colgroup', {}, ...generateColgroup(table)]);
-  return rendered.dom;
-}