@atlaskit/editor-core 187.8.13 → 187.9.0

package/dist/esm/plugins/media/ui/ResizableMediaSingle/ResizableMediaSingleNext.js

@@ -0,0 +1,564 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { findParentNodeOfTypeClosestToPos, hasParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
+import { getMediaClient } from '@atlaskit/media-client';
+import { calcPctFromPx, wrappedLayouts, handleSides, imageAlignmentMap, calcColumnsFromPx, DEFAULT_IMAGE_WIDTH } from '@atlaskit/editor-common/ui';
+import { nonWrappedLayouts, setNodeSelection } from '@atlaskit/editor-common/utils';
+import { akEditorFullWidthLayoutWidth, akEditorGutterPadding, akEditorDefaultLayoutWidth } from '@atlaskit/editor-shared-styles';
+import { wrapperStyle } from './styled';
+import { ResizerNext } from '@atlaskit/editor-common/resizer';
+import ResizeLabel from '../../../../ui/Resizer/ResizeLabel';
+import { injectIntl } from 'react-intl-next';
+import { messages } from './resizable-media-single-messages';
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import classnames from 'classnames';
+import { richMediaClassName, resizerStyles } from '@atlaskit/editor-common/styles';
+import { MEDIA_SINGLE_MIN_PIXEL_WIDTH, MEDIA_SINGLE_SNAP_GAP, MEDIA_SINGLE_HIGHLIGHT_GAP } from '@atlaskit/editor-common/media-single';
+import { findClosestSnap, getSnapWidth, getGuidelinesWithHighlights } from '@atlaskit/editor-common/guideline';
+import { generateDefaultGuidelines, generateDynamicGuidelines } from './guidelines';
+export var resizerNextTestId = 'mediaSingle.resizerNext.testid';
+export function calcOffsetLeft(insideInlineLike, insideLayout, pmViewDom, wrapper) {
+  if (wrapper && insideInlineLike && !insideLayout) {
+    var currentNode = wrapper;
+    var boundingRect = currentNode.getBoundingClientRect();
+    return boundingRect.left - pmViewDom.getBoundingClientRect().left;
+  }
+  return 0;
+}
+
+// TODO: Create new fixed image size event
+var getResizeAnalyticsEvent = function getResizeAnalyticsEvent(type, size, layout) {
+  var actionSubject = type === 'embed' ? ACTION_SUBJECT.EMBEDS : ACTION_SUBJECT.MEDIA_SINGLE;
+  return {
+    action: ACTION.EDITED,
+    actionSubject: actionSubject,
+    actionSubjectId: ACTION_SUBJECT_ID.RESIZED,
+    attributes: {
+      size: size,
+      layout: layout
+    },
+    eventType: EVENT_TYPE.UI
+  };
+};
+var ResizableMediaSingleNext = /*#__PURE__*/function (_React$Component) {
+  _inherits(ResizableMediaSingleNext, _React$Component);
+  var _super = _createSuper(ResizableMediaSingleNext);
+  function ResizableMediaSingleNext(props) {
+    var _this;
+    _classCallCheck(this, ResizableMediaSingleNext);
+    _this = _super.call(this, props);
+    _defineProperty(_assertThisInitialized(_this), "calcNewSize", function (newWidth, stop) {
+      var _this$props = _this.props,
+        layout = _this$props.layout,
+        state = _this$props.view.state,
+        containerWidth = _this$props.containerWidth,
+        lineLength = _this$props.lineLength;
+      var newPct = calcPctFromPx(newWidth, _this.props.lineLength) * 100;
+      _this.setState({
+        resizedPctWidth: newPct
+      });
+      var newLayout = hasParentNodeOfType(state.schema.nodes.table)(state.selection) ? layout : _this.calcUnwrappedLayout(newWidth, containerWidth, lineLength);
+      if (newPct <= 100) {
+        if (_this.wrappedLayout && (stop ? newPct !== 100 : true)) {
+          newLayout = layout;
+        }
+        return {
+          width: newPct,
+          layout: newLayout
+        };
+      } else {
+        return {
+          width: _this.props.pctWidth || null,
+          layout: newLayout
+        };
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "calcUnwrappedLayout", function (width, containerWidth, contentWidth) {
+      if (width <= contentWidth) {
+        return 'center';
+      }
+      if (width < Math.min(containerWidth - akEditorGutterPadding * 2, akEditorFullWidthLayoutWidth)) {
+        return 'wide';
+      }
+
+      // set full width to be containerWidth - akEditorGutterPadding * 2
+      // instead of containerWidth - akEditorBreakoutPadding,
+      // so that we have image aligned with text
+      return 'full-width';
+    });
+    _defineProperty(_assertThisInitialized(_this), "calcColumnLeftOffset", function () {
+      var offsetLeft = _this.state.offsetLeft;
+      return _this.insideInlineLike ? calcColumnsFromPx(offsetLeft, _this.props.lineLength, _this.props.gridSize) : 0;
+    });
+    _defineProperty(_assertThisInitialized(_this), "calcPxHeight", function (newWidth) {
+      var _this$props2 = _this.props,
+        _this$props2$width = _this$props2.width,
+        width = _this$props2$width === void 0 ? newWidth : _this$props2$width,
+        height = _this$props2.height;
+      return Math.round(height / width * newWidth);
+    });
+    _defineProperty(_assertThisInitialized(_this), "saveWrapper", function (wrapper) {
+      return _this.wrapper = wrapper;
+    });
+    _defineProperty(_assertThisInitialized(_this), "displayGuideline", function (guidelines) {
+      var _pluginInjectionApi$d, _pluginInjectionApi$d2, _pluginInjectionApi$d3;
+      var pluginInjectionApi = _this.props.pluginInjectionApi;
+      pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$d = pluginInjectionApi.dependencies) === null || _pluginInjectionApi$d === void 0 ? void 0 : (_pluginInjectionApi$d2 = _pluginInjectionApi$d.guideline) === null || _pluginInjectionApi$d2 === void 0 ? void 0 : (_pluginInjectionApi$d3 = _pluginInjectionApi$d2.actions) === null || _pluginInjectionApi$d3 === void 0 ? void 0 : _pluginInjectionApi$d3.displayGuideline(_this.props.view)({
+        guidelines: guidelines
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "setIsResizing", function (isResizing) {
+      var _this$props$view = _this.props.view,
+        state = _this$props$view.state,
+        dispatch = _this$props$view.dispatch;
+      var tr = state.tr;
+      tr.setMeta('mediaSinglePlugin.isResizing', isResizing);
+      return dispatch(tr);
+    });
+    var initialWidth = props.mediaSingleWidth || _this.calcInitialWidth();
+    _this.state = {
+      offsetLeft: calcOffsetLeft(_this.insideInlineLike, _this.insideLayout, _this.props.view.dom, undefined),
+      // We default to true until we resolve the file type
+      isVideoFile: true,
+      isResizing: false,
+      size: {
+        width: initialWidth,
+        height: _this.calcPxHeight(initialWidth)
+      }
+    };
+    return _this;
+  }
+
+  /**
+   * Calculate media single node initial width if props.mediaSingleWidth is undefined
+   * (Mainly when switching from lagacy experience to new experience).
+   *
+   * @returns initial width in pixel
+   */
+  _createClass(ResizableMediaSingleNext, [{
+    key: "calcInitialWidth",
+    value: function calcInitialWidth() {
+      var _this$props3 = this.props,
+        origWidth = _this$props3.width,
+        contentWidth = _this$props3.lineLength,
+        containerWidth = _this$props3.containerWidth;
+      return Math.max(Math.min(origWidth || DEFAULT_IMAGE_WIDTH, contentWidth || containerWidth || akEditorDefaultLayoutWidth), MEDIA_SINGLE_MIN_PIXEL_WIDTH);
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      var offsetLeft = calcOffsetLeft(this.insideInlineLike, this.insideLayout, this.props.view.dom, this.wrapper);
+      if (offsetLeft !== this.state.offsetLeft && offsetLeft >= 0) {
+        this.setState({
+          offsetLeft: offsetLeft
+        });
+      }
+
+      // Handle undo, when the actual pctWidth changed,
+      // we sync up with the internal state.
+      if (prevProps.pctWidth !== this.props.pctWidth) {
+        this.setState({
+          resizedPctWidth: this.props.pctWidth
+        });
+      }
+      if (prevState.isResizing !== this.state.isResizing && this.state.isResizing) {
+        var guidelines = this.getDefaultGuidelines();
+        this.displayGuideline(guidelines);
+      }
+      if (prevProps.lineLength === undefined && this.props.lineLength !== undefined && this.props.mediaSingleWidth === null) {
+        // re-initalises size when lineLength becomes defined later
+        // ensures extended experience renders legacy image with the same size as the legacy experience
+        var initialWidth = this.calcInitialWidth();
+        this.setState({
+          size: {
+            width: initialWidth,
+            height: this.calcPxHeight(initialWidth)
+          }
+        });
+      }
+      return true;
+    }
+
+    // check if is inside of layout, table, expand, nestedExpand and list item
+  }, {
+    key: "isNestedNode",
+    value: function isNestedNode() {
+      return !!(this.$pos && this.$pos.parent.type.name !== 'doc');
+    }
+  }, {
+    key: "getDefaultGuidelines",
+    value: function getDefaultGuidelines() {
+      var _this$props4 = this.props,
+        lineLength = _this$props4.lineLength,
+        containerWidth = _this$props4.containerWidth,
+        fullWidthMode = _this$props4.fullWidthMode;
+
+      // disable guidelines for nested media single node
+      return this.isNestedNode() ? [] : generateDefaultGuidelines(lineLength, containerWidth, fullWidthMode);
+    }
+
+    // Calculate width of media nodes for snaps based on dynamic guidelines
+    // TODO:  refactor this later, maybe use state to hold snaps array
+  }, {
+    key: "getSnaps",
+    value: function getSnaps() {
+      var view = this.props.view;
+      var dom = view.dom;
+      var defaultGuidelines = this.getDefaultGuidelines();
+      // disable guidelines for nested media single node
+      var dynamicGuidelines = this.isNestedNode() ? [] : generateDynamicGuidelines(view);
+      var guidelines = [].concat(_toConsumableArray(defaultGuidelines), _toConsumableArray(dynamicGuidelines));
+      var mediaSingleSelector = 'div.mediaSingleView-content-wrap.ProseMirror-selectednode';
+      var _dom$getBoundingClien = dom.getBoundingClientRect(),
+        width = _dom$getBoundingClien.width;
+      var halfWidth = width / 2;
+      var selectedMedia = dom.querySelector(mediaSingleSelector);
+      if (selectedMedia) {
+        var pixelWidth = parseFloat(selectedMedia.getAttribute('width') || '') || 0;
+        var layout = selectedMedia.getAttribute('layout');
+        var snap = 0;
+        switch (layout) {
+          case 'align-start':
+          case 'wrap-left':
+            snap = pixelWidth - halfWidth;
+            break;
+          case 'align-end':
+          case 'wrap-right':
+            snap = width - pixelWidth - halfWidth;
+            break;
+          case 'center':
+          case 'wide':
+          case 'full-width':
+            snap = -pixelWidth / 2;
+            break;
+          // we ingnore full-width and wide
+          default:
+            snap = 0;
+        }
+        var snapWidths = getSnapWidth(guidelines, pixelWidth, snap, layout);
+        var snapToWidths = snapWidths.map(function (s) {
+          return s && s.width;
+        });
+
+        // update guidelines
+        if (this.state.isResizing) {
+          var _findClosestSnap = findClosestSnap(this.state.size.width, snapToWidths, snapWidths, MEDIA_SINGLE_HIGHLIGHT_GAP),
+            gap = _findClosestSnap.gap,
+            activeGuidelineKeys = _findClosestSnap.keys;
+          this.displayGuideline(getGuidelinesWithHighlights(gap, MEDIA_SINGLE_HIGHLIGHT_GAP, activeGuidelineKeys, guidelines));
+        }
+        return snapToWidths.length > 0 ? {
+          x: snapToWidths
+        } : {};
+      }
+      return {};
+    }
+  }, {
+    key: "wrappedLayout",
+    get: function get() {
+      return wrappedLayouts.indexOf(this.props.layout) > -1;
+    }
+  }, {
+    key: "componentDidMount",
+    value: function () {
+      var _componentDidMount = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var viewMediaClientConfig;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              viewMediaClientConfig = this.props.viewMediaClientConfig;
+              if (!viewMediaClientConfig) {
+                _context.next = 4;
+                break;
+              }
+              _context.next = 4;
+              return this.checkVideoFile(viewMediaClientConfig);
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function componentDidMount() {
+        return _componentDidMount.apply(this, arguments);
+      }
+      return componentDidMount;
+    }()
+  }, {
+    key: "UNSAFE_componentWillReceiveProps",
+    value: function UNSAFE_componentWillReceiveProps(nextProps) {
+      if (this.props.viewMediaClientConfig !== nextProps.viewMediaClientConfig) {
+        this.checkVideoFile(nextProps.viewMediaClientConfig);
+      }
+    }
+  }, {
+    key: "checkVideoFile",
+    value: function () {
+      var _checkVideoFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(viewMediaClientConfig) {
+        var $pos, mediaNode, mediaClient, state;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              $pos = this.$pos;
+              if (!(!$pos || !viewMediaClientConfig)) {
+                _context2.next = 3;
+                break;
+              }
+              return _context2.abrupt("return");
+            case 3:
+              mediaNode = this.props.view.state.doc.nodeAt($pos.pos + 1);
+              if (!(!mediaNode || !mediaNode.attrs.id)) {
+                _context2.next = 6;
+                break;
+              }
+              return _context2.abrupt("return");
+            case 6:
+              mediaClient = getMediaClient(viewMediaClientConfig);
+              _context2.prev = 7;
+              _context2.next = 10;
+              return mediaClient.file.getCurrentState(mediaNode.attrs.id, {
+                collectionName: mediaNode.attrs.collection
+              });
+            case 10:
+              state = _context2.sent;
+              if (state && state.status !== 'error' && state.mediaType === 'image') {
+                this.setState({
+                  isVideoFile: false
+                });
+              }
+              _context2.next = 17;
+              break;
+            case 14:
+              _context2.prev = 14;
+              _context2.t0 = _context2["catch"](7);
+              this.setState({
+                isVideoFile: false
+              });
+            case 17:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[7, 14]]);
+      }));
+      function checkVideoFile(_x) {
+        return _checkVideoFile.apply(this, arguments);
+      }
+      return checkVideoFile;
+    }()
+  }, {
+    key: "$pos",
+    get: function get() {
+      if (typeof this.props.getPos !== 'function') {
+        return null;
+      }
+      var pos = this.props.getPos();
+      if (Number.isNaN(pos) || typeof pos !== 'number') {
+        return null;
+      }
+
+      // need to pass view because we may not get updated props in time
+      return this.props.view.state.doc.resolve(pos);
+    }
+
+    /**
+     * The maxmimum number of grid columns this node can resize to.
+     */
+  }, {
+    key: "gridWidth",
+    get: function get() {
+      var gridSize = this.props.gridSize;
+      return !(this.wrappedLayout || this.insideInlineLike) ? gridSize / 2 : gridSize;
+    }
+  }, {
+    key: "insideInlineLike",
+    get: function get() {
+      var $pos = this.$pos;
+      if (!$pos) {
+        return false;
+      }
+      var listItem = this.props.view.state.schema.nodes.listItem;
+      return !!findParentNodeOfTypeClosestToPos($pos, [listItem]);
+    }
+  }, {
+    key: "insideLayout",
+    get: function get() {
+      var $pos = this.$pos;
+      if (!$pos) {
+        return false;
+      }
+      var layoutColumn = this.props.view.state.schema.nodes.layoutColumn;
+      return !!findParentNodeOfTypeClosestToPos($pos, [layoutColumn]);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$props5 = this.props,
+        origWidth = _this$props5.width,
+        layout = _this$props5.layout,
+        pctWidth = _this$props5.pctWidth,
+        containerWidth = _this$props5.containerWidth,
+        fullWidthMode = _this$props5.fullWidthMode,
+        selected = _this$props5.selected,
+        children = _this$props5.children,
+        intl = _this$props5.intl;
+      var _this$state = this.state,
+        isResizing = _this$state.isResizing,
+        size = _this$state.size;
+      var enable = {};
+      handleSides.forEach(function (side) {
+        var oppositeSide = side === 'left' ? 'right' : 'left';
+        enable[side] = nonWrappedLayouts.concat("wrap-".concat(oppositeSide)).concat("align-".concat(imageAlignmentMap[oppositeSide])).indexOf(layout) > -1;
+        if (side === 'left' && _this2.insideInlineLike) {
+          enable[side] = false;
+        }
+      });
+
+      /**
+       * NEW REFACTOR
+       */
+      var roundPixelValue = function roundPixelValue(value) {
+        return Math.round(value);
+      };
+      var getHeightFromNewWidth = function getHeightFromNewWidth(originalWidth, originalHeight, newWidth) {
+        return roundPixelValue(originalHeight / originalWidth * newWidth);
+      };
+      var calculateSizeState = function calculateSizeState(size, delta) {
+        var originalWidth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+        var originalHeight = arguments.length > 3 ? arguments[3] : undefined;
+        var onResizeStop = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+        var calculatedWidth = roundPixelValue(size.width + delta.width);
+        var calculatedWidthWithLayout = _this2.calcNewSize(calculatedWidth, onResizeStop);
+        var calculatedHeightWithLayout = getHeightFromNewWidth(originalWidth, originalHeight, calculatedWidth);
+        return {
+          width: calculatedWidth,
+          height: calculatedHeightWithLayout,
+          calculatedWidthWithLayout: calculatedWidthWithLayout
+        };
+      };
+      var selectCurrentMediaNode = function selectCurrentMediaNode() {
+        if (!_this2.props.selected && typeof _this2.props.getPos === 'function') {
+          var propPos = _this2.props.getPos();
+          if (propPos !== undefined) {
+            setNodeSelection(_this2.props.view, propPos);
+          }
+        }
+      };
+      var handleResizeStart = function handleResizeStart() {
+        _this2.setState({
+          isResizing: true
+        });
+        selectCurrentMediaNode();
+        _this2.setIsResizing(true);
+
+        // TODO: Update once type updated from editor common resizer
+        return 0;
+      };
+      var handleResize = function handleResize(size, delta) {
+        var _this2$props = _this2.props,
+          originalWidth = _this2$props.width,
+          originalHeight = _this2$props.height,
+          layout = _this2$props.layout,
+          updateSize = _this2$props.updateSize;
+        var _calculateSizeState = calculateSizeState(size, delta, originalWidth, originalHeight),
+          width = _calculateSizeState.width,
+          height = _calculateSizeState.height,
+          calculatedWidthWithLayout = _calculateSizeState.calculatedWidthWithLayout;
+        _this2.setState({
+          size: {
+            width: width,
+            height: height
+          }
+        });
+        if (calculatedWidthWithLayout.layout !== layout) {
+          updateSize(width, calculatedWidthWithLayout.layout);
+        }
+
+        // TODO: Update once type updated from editor common resizer
+        return 0;
+      };
+      var handleResizeStop = function handleResizeStop(size, delta) {
+        var _this2$props2 = _this2.props,
+          originalWidth = _this2$props2.width,
+          originalHeight = _this2$props2.height,
+          updateSize = _this2$props2.updateSize,
+          dispatchAnalyticsEvent = _this2$props2.dispatchAnalyticsEvent,
+          nodeType = _this2$props2.nodeType;
+        var _calculateSizeState2 = calculateSizeState(size, delta, originalWidth, originalHeight, true),
+          width = _calculateSizeState2.width,
+          height = _calculateSizeState2.height,
+          calculatedWidthWithLayout = _calculateSizeState2.calculatedWidthWithLayout;
+        _this2.setIsResizing(false);
+        _this2.displayGuideline([]);
+        if (dispatchAnalyticsEvent) {
+          dispatchAnalyticsEvent(getResizeAnalyticsEvent(nodeType, calculatedWidthWithLayout.width, calculatedWidthWithLayout.layout));
+        }
+        _this2.setState({
+          isResizing: false,
+          size: {
+            width: width,
+            height: height
+          }
+        }, function () {
+          updateSize(width, calculatedWidthWithLayout.layout);
+        });
+
+        // TODO: Update once type updated from editor common resizer
+        return 0;
+      };
+
+      // TODO: Clean up where this lives and how it gets generated
+      var className = classnames(richMediaClassName, "image-".concat(layout), isResizing ? 'is-resizing' : 'not-resizing', this.props.className, {
+        'not-resized': !pctWidth,
+        'richMedia-selected': selected,
+        'rich-media-wrapped': layout === 'wrap-left' || layout === 'wrap-right'
+      });
+      var resizerNextClassName = classnames(className, resizerStyles);
+      var showSizeGuide = selected || isResizing;
+      var label = layout === 'full-width' ? intl.formatMessage(messages.fullWidthImage) : "".concat(this.state.size.width, " x ").concat(this.state.size.height);
+      return jsx("div", {
+        ref: this.saveWrapper,
+        css: wrapperStyle({
+          layout: layout,
+          isResized: !!pctWidth,
+          containerWidth: containerWidth || origWidth,
+          fullWidthMode: fullWidthMode,
+          mediaSingleWidth: this.state.size.width,
+          isNestedNode: this.isNestedNode(),
+          isExtendedResizeExperienceOn: true
+        })
+      }, jsx(ResizerNext, {
+        minWidth: MEDIA_SINGLE_MIN_PIXEL_WIDTH,
+        className: resizerNextClassName,
+        snapGap: MEDIA_SINGLE_SNAP_GAP,
+        enable: enable,
+        width: size.width,
+        handleResizeStart: handleResizeStart,
+        handleResize: handleResize,
+        handleResizeStop: handleResizeStop,
+        snap: this.getSnaps(),
+        resizeRatio: nonWrappedLayouts.includes(layout) ? 2 : 1,
+        "data-testid": resizerNextTestId
+      }, showSizeGuide && jsx(ResizeLabel, {
+        label: label,
+        containerWidth: this.state.size.width
+      }), children));
+    }
+  }]);
+  return ResizableMediaSingleNext;
+}(React.Component); // for testing purpose
+export { ResizableMediaSingleNext as UnwrappedResizableMediaSingleNext };
+export default injectIntl(ResizableMediaSingleNext);

package/dist/esm/plugins/media/ui/ResizableMediaSingle/guidelines.js

@@ -0,0 +1,108 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import memoizeOne from 'memoize-one';
+import { akEditorGutterPadding, akEditorFullWidthLayoutWidth, breakoutWideScaleRatio } from '@atlaskit/editor-shared-styles';
+import { MEDIA_DYNAMIC_GUIDELINE_PREFIX } from '@atlaskit/editor-common/guideline';
+var mediaSingleSelector = 'div.mediaSingleView-content-wrap:not(.ProseMirror-selectednode)';
+var getDefaultGuidelines = memoizeOne(function (editorWidth) {
+  return [-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6].map(function (val, index) {
+    return {
+      key: "grid_".concat(index),
+      position: {
+        x: val / 12 * editorWidth
+      }
+    };
+  });
+});
+var getWideGuidelines = memoizeOne(function (editorWidth) {
+  var wideSpacing = editorWidth * breakoutWideScaleRatio / 2;
+  return [{
+    key: "wide_left",
+    position: {
+      x: -wideSpacing
+    }
+  }, {
+    key: "wide_right",
+    position: {
+      x: wideSpacing
+    }
+  }];
+});
+var getFullWidthGuidelines = memoizeOne(function (containerWidth) {
+  var fullWidth = Math.min(containerWidth - akEditorGutterPadding * 2, akEditorFullWidthLayoutWidth) / 2;
+  return [{
+    key: "full_width_left",
+    position: {
+      x: -fullWidth
+    }
+  }, {
+    key: "full_width_right",
+    position: {
+      x: fullWidth
+    }
+  }];
+});
+export var generateDefaultGuidelines = function generateDefaultGuidelines(editorWidth, containerWidth) {
+  var isFullWidthMode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var innerGrids = getDefaultGuidelines(editorWidth);
+  var wideGuidelines = !isFullWidthMode ? getWideGuidelines(editorWidth) : [];
+  var fullWidthGuidelines = !isFullWidthMode ? getFullWidthGuidelines(containerWidth) : [];
+  return [].concat(_toConsumableArray(innerGrids), _toConsumableArray(wideGuidelines), _toConsumableArray(fullWidthGuidelines));
+};
+export var generateDynamicGuidelines = function generateDynamicGuidelines(view) {
+  var dom = view.dom;
+  var _dom$getBoundingClien = dom.getBoundingClientRect(),
+    width = _dom$getBoundingClien.width;
+  var halfWidth = width / 2;
+  var keyIdx = 0;
+  var dynamicGuidelines = _toConsumableArray(dom.querySelectorAll(mediaSingleSelector)).map(function (elem, _index) {
+    var pixelWidthAttr = elem.getAttribute('widthType') === 'pixel' ? elem.getAttribute('width') : '';
+    var pixelWidth = parseFloat(pixelWidthAttr || '');
+    if (Number.isNaN(pixelWidth)) {
+      return [];
+    }
+    var commonStyles = {
+      styles: {
+        lineStyle: 'dashed'
+      },
+      show: false
+    };
+    var key = "".concat(MEDIA_DYNAMIC_GUIDELINE_PREFIX).concat(++keyIdx);
+    switch (elem.getAttribute('layout')) {
+      case 'align-start':
+      case 'wrap-left':
+        return _objectSpread({
+          position: {
+            x: pixelWidth - halfWidth
+          },
+          key: key
+        }, commonStyles);
+      case 'align-end':
+      case 'wrap-right':
+        return _objectSpread({
+          position: {
+            x: width - pixelWidth - halfWidth
+          },
+          key: key
+        }, commonStyles);
+      case 'center':
+        return [_objectSpread({
+          position: {
+            x: pixelWidth / 2
+          },
+          key: key
+        }, commonStyles), _objectSpread({
+          position: {
+            x: -pixelWidth / 2
+          },
+          key: key
+        }, commonStyles)];
+      // we ignore full-width and wide
+      default:
+        return [];
+    }
+  }).flat();
+  return dynamicGuidelines;
+};

package/dist/esm/plugins/media/ui/ResizableMediaSingle/resizable-media-single-messages.js

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl-next';
+export var messages = defineMessages({
+  fullWidthImage: {
+    id: 'fabric.editor.image.fullWidthImage',
+    defaultMessage: 'Full width image',
+    description: 'The image has reached its full width'
+  }
+});