@atlaskit/renderer 105.1.1 → 105.1.2

package/dist/es2019/react/nodes/table.js

@@ -11,12 +11,10 @@ import { withSmartCardStorage } from '../../ui/SmartCardStorage';
 import { StickyTable, tableStickyPadding, OverflowParent } from './table/sticky';
 import { Table } from './table/table';
 import { akEditorDefaultLayoutWidth } from '@atlaskit/editor-shared-styles';
-
 const orderChildren = (children, tableNode, smartCardStorage, tableOrderStatus) => {
   if (!tableOrderStatus || tableOrderStatus.order === SortOrder.NO_ORDER) {
     return children;
   }
-
   const {
     order,
     columnIndex
@@ -26,14 +24,11 @@ const orderChildren = (children, tableNode, smartCardStorage, tableOrderStatus)
       const {
         url
       } = attrs;
-
       if (!url) {
         return null;
       }
-
       return smartCardStorage.get(url) || null;
     }
-
   }, order);
   const tableArray = convertProsemirrorTableNodeToArrayOfRows(tableNode);
   const tableArrayWithChildren = tableArray.map((rowNodes, index) => ({
@@ -42,28 +37,21 @@ const orderChildren = (children, tableNode, smartCardStorage, tableOrderStatus)
   }));
   const headerRow = tableArrayWithChildren.shift();
   const sortedTable = tableArrayWithChildren.sort((rowA, rowB) => compareNodesInOrder(rowA.rowNodes[columnIndex], rowB.rowNodes[columnIndex]));
-
   if (headerRow) {
     sortedTable.unshift(headerRow);
   }
-
   return sortedTable.map(elem => elem.rowReact);
 };
-
 const hasRowspan = row => {
   let hasRowspan = false;
   row.forEach(cell => hasRowspan = hasRowspan || cell.attrs.rowspan > 1);
   return hasRowspan;
 };
-
 const getRefTop = refElement => {
   return Math.round(refElement.getBoundingClientRect().top);
 };
-
 const shouldHeaderStick = (scrollTop, tableTop, tableBottom, rowHeight) => tableTop <= scrollTop && !(tableBottom - rowHeight <= scrollTop);
-
 const shouldHeaderPinBottom = (scrollTop, tableBottom, rowHeight) => tableBottom - rowHeight <= scrollTop && !(tableBottom < scrollTop);
-
 const addSortableColumn = (rows, tableOrderStatus, onSorting) => {
   return React.Children.map(rows, (row, index) => {
     if (index === 0) {
@@ -72,65 +60,47 @@ const addSortableColumn = (rows, tableOrderStatus, onSorting) => {
         onSorting
       });
     }
-
     return row;
   });
 };
-
 const isHeaderRowEnabled = rows => {
   if (!rows.length) {
     return false;
   }
-
   const {
     children
   } = rows[0].props;
-
   if (!children.length) {
     return false;
   }
-
   if (children.length === 1) {
     return children[0].type === TableHeader;
   }
-
   return children.every(node => node.type === TableHeader);
 };
-
 const tableCanBeSticky = (node, children) => {
   return isHeaderRowEnabled(children) && node && node.firstChild && !hasRowspan(node.firstChild);
 };
-
 const canUseLinelength = appearance => appearance === 'full-page' || appearance === 'mobile';
-
 export class TableContainer extends React.Component {
   constructor(...args) {
     super(...args);
-
     _defineProperty(this, "state", {
       stickyMode: 'none'
     });
-
     _defineProperty(this, "tableRef", /*#__PURE__*/React.createRef());
-
     _defineProperty(this, "stickyHeaderRef", /*#__PURE__*/React.createRef());
-
     _defineProperty(this, "stickyWrapperRef", /*#__PURE__*/React.createRef());
-
     _defineProperty(this, "wrapperRef", /*#__PURE__*/React.createRef());
-
     _defineProperty(this, "overflowParent", null);
-
     _defineProperty(this, "componentWillUnmount", () => {
       if (this.overflowParent) {
         this.overflowParent.removeEventListener('scroll', this.onScroll);
       }
-
       if (this.nextFrame) {
         cancelAnimationFrame(this.nextFrame);
       }
     });
-
     _defineProperty(this, "getScrollTop", () => {
       const {
         stickyHeaders
@@ -138,51 +108,41 @@ export class TableContainer extends React.Component {
       const offsetTop = stickyHeaders && stickyHeaders.offsetTop || 0;
       return (this.overflowParent ? this.overflowParent.top : 0) + offsetTop;
     });
-
     _defineProperty(this, "updateSticky", () => {
       const tableElem = this.tableRef.current;
       const refElem = this.stickyHeaderRef.current;
-
       if (!tableElem || !refElem) {
         return;
       }
-
       const scrollTop = this.getScrollTop() + tableStickyPadding;
       const tableTop = getRefTop(tableElem);
       const tableBottom = tableTop + tableElem.clientHeight;
       const shouldSticky = shouldHeaderStick(scrollTop, tableTop, tableBottom, refElem.clientHeight);
       const shouldPin = shouldHeaderPinBottom(scrollTop, tableBottom, refElem.clientHeight);
       let stickyMode = 'none';
-
       if (shouldPin) {
         stickyMode = 'pin-bottom';
       } else if (shouldSticky) {
         stickyMode = 'stick';
       }
-
       if (this.state.stickyMode !== stickyMode) {
         this.setState({
           stickyMode
         });
       }
-
       this.nextFrame = undefined;
     });
-
     _defineProperty(this, "onScroll", () => {
       if (!this.nextFrame) {
         this.nextFrame = requestAnimationFrame(this.updateSticky);
       }
     });
-
     _defineProperty(this, "onWrapperScrolled", () => {
       if (!this.wrapperRef.current || !this.stickyWrapperRef.current) {
         return;
       }
-
       this.stickyWrapperRef.current.scrollLeft = this.wrapperRef.current.scrollLeft;
     });
-
     _defineProperty(this, "grabFirstRowRef", children => {
       return React.Children.map(children, (child, idx) => {
         if (idx === 0 && /*#__PURE__*/React.isValidElement(child)) {
@@ -190,19 +150,16 @@ export class TableContainer extends React.Component {
             innerRef: this.stickyHeaderRef
           });
         }
-
         return child;
       });
     });
   }
-
   componentDidMount() {
     if (this.props.stickyHeaders) {
       this.overflowParent = OverflowParent.fromElement(this.tableRef.current);
       this.overflowParent.addEventListener('scroll', this.onScroll);
     }
   }
-
   componentDidUpdate(prevProps, prevState) {
     // toggling sticky headers visiblity
     if (this.props.stickyHeaders && !this.overflowParent) {
@@ -210,44 +167,37 @@ export class TableContainer extends React.Component {
     } else if (!this.props.stickyHeaders && this.overflowParent) {
       this.overflowParent.removeEventListener('scroll', this.onScroll);
       this.overflowParent = null;
-    } // offsetTop might have changed, re-position sticky header
-
+    }
 
+    // offsetTop might have changed, re-position sticky header
     if (this.props.stickyHeaders !== prevProps.stickyHeaders) {
       this.updateSticky();
-    } // sync horizontal scroll in floating div when toggling modes
-
+    }
 
+    // sync horizontal scroll in floating div when toggling modes
     if (prevState.stickyMode !== this.state.stickyMode) {
       this.onWrapperScrolled();
     }
   }
-
   get pinTop() {
     if (!this.tableRef.current || !this.stickyHeaderRef.current) {
       return;
     }
-
     return this.tableRef.current.offsetHeight - this.stickyHeaderRef.current.offsetHeight + tableMarginTop - tableStickyPadding;
   }
-
   get stickyTop() {
     switch (this.state.stickyMode) {
       case 'pin-bottom':
         return this.pinTop;
-
       case 'stick':
         return this.props.stickyHeaders && this.props.stickyHeaders.offsetTop;
-
       default:
         return undefined;
     }
   }
-
   get headerRowHeight() {
     return this.stickyHeaderRef.current ? this.stickyHeaderRef.current.offsetHeight : 0;
   }
-
   render() {
     const {
       isNumberColumnEnabled,
@@ -263,12 +213,10 @@ export class TableContainer extends React.Component {
     let tableWidth = calcTableWidth(layout, renderWidth, false);
     const lineLength = akEditorDefaultLayoutWidth;
     let left;
-
     if (canUseLinelength(this.props.rendererAppearance) && tableWidth !== 'inherit') {
       const tableWidthPx = Number(tableWidth.substring(0, tableWidth.length - 2));
       left = lineLength / 2 - tableWidthPx / 2;
     }
-
     const wrapperWidth = this.wrapperRef.current ? this.wrapperRef.current.clientWidth : 0;
     const children = React.Children.toArray(this.props.children);
     return /*#__PURE__*/React.createElement(React.Fragment, null, stickyHeaders && tableCanBeSticky(tableNode, children) && /*#__PURE__*/React.createElement(StickyTable, {
@@ -305,16 +253,13 @@ export class TableContainer extends React.Component {
       renderWidth: renderWidth
     }, this.grabFirstRowRef(children)))));
   }
-
 }
 export class TableProcessor extends React.Component {
   constructor(...args) {
     super(...args);
-
     _defineProperty(this, "state", {
       tableOrderStatus: undefined
     });
-
     _defineProperty(this, "addSortableColumn", childrenArray => {
       const {
         tableNode,
@@ -324,14 +269,11 @@ export class TableProcessor extends React.Component {
       const {
         tableOrderStatus
       } = this.state;
-
       if (allowColumnSorting && isHeaderRowEnabled(childrenArray) && tableNode && !hasMergedCell(tableNode)) {
         return addSortableColumn(orderChildren(childrenArray, tableNode, smartCardStorage, tableOrderStatus), tableOrderStatus, this.changeSortOrder);
       }
-
       return childrenArray;
     });
-
     _defineProperty(this, "changeSortOrder", (columnIndex, sortOrder) => {
       this.setState({
         tableOrderStatus: {
@@ -340,7 +282,6 @@ export class TableProcessor extends React.Component {
         }
       });
     });
-
     _defineProperty(this, "addNumberColumnIndexes", rows => {
       const {
         isNumberColumnEnabled
@@ -354,46 +295,39 @@ export class TableProcessor extends React.Component {
       });
     });
   }
-
   render() {
     const {
       children
     } = this.props;
-
     if (!children) {
       return null;
     }
-
     let childrenArray = React.Children.toArray(children);
     const orderedChildren = compose(this.addNumberColumnIndexes, this.addSortableColumn)(childrenArray);
     return /*#__PURE__*/React.createElement(TableContainer, this.props, orderedChildren);
-  } // adds sortable + re-orders children
-
+  }
 
+  // adds sortable + re-orders children
 }
+
 const TableWithShadows = overflowShadow(TableProcessor, {
   overflowSelector: `.${TableSharedCssClassName.TABLE_NODE_WRAPPER}`,
   useShadowObserver: true
 });
-
 const TableWithWidth = props => /*#__PURE__*/React.createElement(WidthConsumer, null, ({
   width
 }) => {
   var _props$columnWidths;
-
   const renderWidth = props.rendererAppearance === 'full-page' ? width - FullPagePadding * 2 : width;
   const colWidthsSum = ((_props$columnWidths = props.columnWidths) === null || _props$columnWidths === void 0 ? void 0 : _props$columnWidths.reduce((total, val) => total + val, 0)) || 0;
-
   if (colWidthsSum) {
     return /*#__PURE__*/React.createElement(TableWithShadows, _extends({
       renderWidth: renderWidth
     }, props));
-  } // there should not be a case when colWidthsSum is 0 and table is in overflow state - so no need to render shadows in this case
-
-
+  }
+  // there should not be a case when colWidthsSum is 0 and table is in overflow state - so no need to render shadows in this case
   return /*#__PURE__*/React.createElement(TableProcessor, _extends({
     renderWidth: renderWidth
   }, props));
 });
-
 export default withSmartCardStorage(TableWithWidth);

package/dist/es2019/react/nodes/tableCell.js

@@ -11,74 +11,57 @@ import { RendererCssClassName } from '../../consts';
 import { injectIntl } from 'react-intl-next';
 import { tableCellMessages } from '../../messages';
 const IgnoreSorting = ['LABEL', 'INPUT'];
-
 const nextStatusOrder = currentSortOrder => {
   switch (currentSortOrder) {
     case SortOrder.NO_ORDER:
       return SortOrder.ASC;
-
     case SortOrder.ASC:
       return SortOrder.DESC;
-
     case SortOrder.DESC:
       return SortOrder.NO_ORDER;
   }
-
   return SortOrder.NO_ORDER;
 };
-
 const getSortOrderLabel = (intl, currentSortOrder) => {
   const {
     noneSortingLabel,
     ascSortingLabel,
     descSortingLabel
   } = tableCellMessages;
-
   switch (currentSortOrder) {
     case SortOrder.NO_ORDER:
       return intl.formatMessage(noneSortingLabel);
-
     case SortOrder.ASC:
       return intl.formatMessage(ascSortingLabel);
-
     case SortOrder.DESC:
       return intl.formatMessage(descSortingLabel);
-
     default:
       return intl.formatMessage(noneSortingLabel);
   }
 };
-
 const getDataAttributes = colwidth => {
   const attrs = {};
-
   if (colwidth) {
     attrs['data-colwidth'] = colwidth.join(',');
   }
-
   return attrs;
 };
-
 const getStyle = (background, colGroupWidth, offsetTop) => {
   const style = {};
-
-  if (background && // ignore setting inline styles if ds neutral token is detected
+  if (background &&
+  // ignore setting inline styles if ds neutral token is detected
   !background.includes('--ds-background-neutral')) {
     style.backgroundColor = background;
   }
-
   if (colGroupWidth) {
     style.width = colGroupWidth;
     style.minWidth = colGroupWidth;
   }
-
   if (offsetTop !== undefined) {
     style.top = offsetTop;
   }
-
   return style;
 };
-
 const withCellProps = WrapperComponent => {
   return class WithCellProps extends React.Component {
     render() {
@@ -106,27 +89,23 @@ const withCellProps = WrapperComponent => {
         "aria-sort": ariaSort
       }), children);
     }
-
   };
 };
-
 export const withSortableColumn = WrapperComponent => {
   class WithSortableColumn extends React.Component {
     constructor(props) {
       super(props);
-
       _defineProperty(this, "onKeyPress", event => {
         const keys = [' ', 'Enter', 'Spacebar'];
         const {
           tagName
-        } = event.target; // trigger sorting if space or enter are clicked but not when in an input field (template variables)
-
+        } = event.target;
+        // trigger sorting if space or enter are clicked but not when in an input field (template variables)
         if (keys.includes(event.key) && !IgnoreSorting.includes(tagName)) {
           event.preventDefault();
           this.sort();
         }
       });
-
       _defineProperty(this, "sort", () => {
         const {
           fireAnalyticsEvent,
@@ -134,7 +113,6 @@ export const withSortableColumn = WrapperComponent => {
           columnIndex,
           sortOrdered
         } = this.props;
-
         if (onSorting && columnIndex != null) {
           const sortOrder = nextStatusOrder(sortOrdered);
           onSorting(columnIndex, sortOrder);
@@ -162,7 +140,6 @@ export const withSortableColumn = WrapperComponent => {
         }
       });
     }
-
     render() {
       const {
         allowColumnSorting,
@@ -173,11 +150,9 @@ export const withSortableColumn = WrapperComponent => {
         intl
       } = this.props;
       const sortOrderedClassName = sortOrdered === SortOrder.NO_ORDER ? RendererCssClassName.SORTABLE_COLUMN_NO_ORDER : '';
-
       if (!allowColumnSorting || !isHeaderRow) {
         return /*#__PURE__*/React.createElement(WrapperComponent, this.props);
       }
-
       return /*#__PURE__*/React.createElement(WrapperComponent, _extends({}, this.props, {
         className: RendererCssClassName.SORTABLE_COLUMN_WRAPPER,
         ariaSort: getSortOrderLabel(intl, sortOrdered)
@@ -192,9 +167,7 @@ export const withSortableColumn = WrapperComponent => {
         onKeyDown: this.onKeyPress
       }))));
     }
-
   }
-
   return injectIntl(WithSortableColumn);
 };
 export const TableHeader = compose(withSortableColumn, withCellProps)('th');

package/dist/es2019/react/nodes/tableRow.js

@@ -6,17 +6,14 @@ import { RendererCssClassName } from '../../consts';
 export default class TableRow extends React.Component {
   constructor(...args) {
     super(...args);
-
     _defineProperty(this, "state", {
       colGroupWidths: []
     });
-
     _defineProperty(this, "addSortableColumn", childrenArray => {
       const {
         allowColumnSorting,
         index: rowIndex
       } = this.props;
-
       if (allowColumnSorting) {
         const isHeaderRow = !rowIndex;
         childrenArray = childrenArray.map((child, index) => {
@@ -25,11 +22,9 @@ export default class TableRow extends React.Component {
               tableOrderStatus
             } = this.props;
             let sortOrdered = SortOrder.NO_ORDER;
-
             if (tableOrderStatus) {
               sortOrdered = index === tableOrderStatus.columnIndex ? tableOrderStatus.order : SortOrder.NO_ORDER;
             }
-
             return /*#__PURE__*/React.cloneElement(child, {
               columnIndex: index,
               onSorting: this.props.onSorting,
@@ -39,10 +34,8 @@ export default class TableRow extends React.Component {
           }
         });
       }
-
       return childrenArray;
     });
-
     _defineProperty(this, "addColGroupWidth", childrenArray => {
       if (this.state.colGroupWidths) {
         childrenArray = childrenArray.map((child, index) => {
@@ -53,11 +46,9 @@ export default class TableRow extends React.Component {
           }
         });
       }
-
       return childrenArray;
     });
   }
-
   render() {
     const {
       children,
@@ -70,5 +61,4 @@ export default class TableRow extends React.Component {
       className: RendererCssClassName.NUMBER_COLUMN
     }, this.props.index), compose(this.addSortableColumn, this.addColGroupWidth)(childrenArray));
   }
-
 }

package/dist/es2019/react/nodes/task-item-with-providers.js

@@ -6,22 +6,18 @@ import { ResourcedTaskItem } from '@atlaskit/task-decision';
 export default class TaskItemWithProviders extends Component {
   constructor(...args) {
     super(...args);
-
     _defineProperty(this, "state", {
       resolvedContextProvider: undefined
     });
   }
-
   UNSAFE_componentWillMount() {
     this.updateContextIdentifierProvider(this.props);
   }
-
   UNSAFE_componentWillReceiveProps(nextProps) {
     if (nextProps.contextIdentifierProvider !== this.props.contextIdentifierProvider) {
       this.updateContextIdentifierProvider(nextProps);
     }
   }
-
   async updateContextIdentifierProvider(props) {
     if (props.contextIdentifierProvider) {
       try {
@@ -40,7 +36,6 @@ export default class TaskItemWithProviders extends Component {
       });
     }
   }
-
   render() {
     const {
       contextIdentifierProvider,
@@ -54,5 +49,4 @@ export default class TaskItemWithProviders extends Component {
       isRenderer: isRenderer
     }));
   }
-
 }

package/dist/es2019/react/nodes/taskItem.js

@@ -8,7 +8,6 @@ import { TaskItemsFormatProvider, TaskItemsFormatConsumer } from '../../ui/TaskI
 export default class TaskItem extends PureComponent {
   constructor(props) {
     super(props);
-
     _defineProperty(this, "renderWithProvider", providers => {
       const {
         taskDecisionProvider,
@@ -23,11 +22,9 @@ export default class TaskItem extends PureComponent {
         dataAttributes
       } = this.props;
       let objectAri = '';
-
       if (rendererContext) {
         objectAri = rendererContext.objectAri || '';
       }
-
       return /*#__PURE__*/React.createElement(FabricElementsAnalyticsContext, {
         data: {
           userContext: 'document'
@@ -46,10 +43,8 @@ export default class TaskItem extends PureComponent {
         }
       }, children))));
     });
-
     this.providerFactory = props.providers || new ProviderFactory();
   }
-
   componentWillUnmount() {
     if (!this.props.providers) {
       // new ProviderFactory is created if no `providers` has been set
@@ -57,7 +52,6 @@ export default class TaskItem extends PureComponent {
       this.providerFactory.destroy();
     }
   }
-
   render() {
     return /*#__PURE__*/React.createElement(WithProviders, {
       providers: ['taskDecisionProvider', 'contextIdentifierProvider'],
@@ -65,5 +59,4 @@ export default class TaskItem extends PureComponent {
       renderNode: this.renderWithProvider
     });
   }
-
 }

package/dist/es2019/react/nodes/taskList.js

@@ -7,14 +7,11 @@ export default class TaskList extends PureComponent {
       children,
       localId
     } = this.props;
-
     if (Children.count(children) === 0) {
       return null;
     }
-
     return /*#__PURE__*/React.createElement(AkTaskList, {
       listId: localId
     }, children);
   }
-
 }

package/dist/es2019/react/nodes/text-wrapper.js

@@ -1,6 +1,5 @@
 import React from 'react';
 import { TextWithAnnotationDraft } from '../../ui/annotations';
-
 const TextWrapper = props => {
   const {
     startPos,
@@ -9,15 +8,12 @@ const TextWrapper = props => {
   const {
     children
   } = props;
-
   if (!children) {
     return null;
   }
-
   return /*#__PURE__*/React.createElement(TextWithAnnotationDraft, {
     startPos: startPos,
     endPos: endPos
   }, children);
 };
-
 export default TextWrapper;

package/dist/es2019/react/utils/clipboard.js

@@ -1,6 +1,5 @@
 export const copyTextToClipboard = text => new Promise((resolve, reject) => {
   const isApiSupported = !!navigator.clipboard && typeof navigator.clipboard.writeText === 'function';
-
   if (isApiSupported) {
     navigator.clipboard.writeText(text).then(() => resolve(), e => reject(e));
   } else {