@atlaskit/editor-core 188.2.11 → 188.3.1

package/dist/esm/plugins/media/nodeviews/mediaInline.js

@@ -1,278 +0,0 @@
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _get from "@babel/runtime/helpers/get";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-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; } }
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-import React, { useEffect, useState } from 'react';
-import { useSharedPluginState } from '@atlaskit/editor-common/hooks';
-import { WithProviders } from '@atlaskit/editor-common/provider-factory';
-import { SelectionBasedNodeView } from '@atlaskit/editor-common/selection-based-node-view';
-import { MediaInlineCard } from '@atlaskit/media-card';
-import { MediaInlineCardLoadingView } from '@atlaskit/media-ui';
-import { MediaNodeUpdater } from './mediaNodeUpdater';
-import { MediaInlineNodeSelector } from './styles';
-export var createMediaNodeUpdater = function createMediaNodeUpdater(props) {
-  var node = props.node;
-  return new MediaNodeUpdater(_objectSpread(_objectSpread({}, props), {}, {
-    isMediaSingle: true,
-    node: node ? node : props.node,
-    dispatchAnalyticsEvent: props.dispatchAnalyticsEvent,
-    contextIdentifierProvider: props.contextIdentifierProvider
-  }));
-};
-
-/**
- * Handles updating the media inline node attributes
- * but also handling copy-paste for cross-editor of the same instance
- * using the contextid
- *
- */
-export var updateMediaNodeAttributes = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(props, mediaNodeUpdater) {
-    var addPendingTask, node, contextId, hasDifferentContextId, copyNode;
-    return _regeneratorRuntime.wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          addPendingTask = props.mediaPluginState.addPendingTask;
-          node = props.node;
-          if (node) {
-            _context.next = 4;
-            break;
-          }
-          return _context.abrupt("return");
-        case 4:
-          contextId = mediaNodeUpdater.getNodeContextId();
-          if (contextId) {
-            _context.next = 8;
-            break;
-          }
-          _context.next = 8;
-          return mediaNodeUpdater.updateContextId();
-        case 8:
-          _context.next = 10;
-          return mediaNodeUpdater.hasDifferentContextId();
-        case 10:
-          hasDifferentContextId = _context.sent;
-          if (!hasDifferentContextId) {
-            _context.next = 22;
-            break;
-          }
-          _context.prev = 12;
-          copyNode = mediaNodeUpdater.copyNode({
-            traceId: node.attrs.__mediaTraceId
-          });
-          addPendingTask(copyNode);
-          _context.next = 17;
-          return copyNode;
-        case 17:
-          _context.next = 22;
-          break;
-        case 19:
-          _context.prev = 19;
-          _context.t0 = _context["catch"](12);
-          return _context.abrupt("return");
-        case 22:
-          _context.next = 24;
-          return mediaNodeUpdater.updateMediaSingleFileAttrs();
-        case 24:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee, null, [[12, 19]]);
-  }));
-  return function updateMediaNodeAttributes(_x, _x2) {
-    return _ref.apply(this, arguments);
-  };
-}();
-export var handleNewNode = function handleNewNode(props) {
-  var node = props.node,
-    mediaPluginState = props.mediaPluginState,
-    getPos = props.getPos;
-  mediaPluginState.handleMediaNodeMount(node, function () {
-    return getPos();
-  });
-};
-export var MediaInline = function MediaInline(props) {
-  var _useState = useState(),
-    _useState2 = _slicedToArray(_useState, 2),
-    viewMediaClientConfig = _useState2[0],
-    setViewMediaClientConfig = _useState2[1];
-  var _useState3 = useState(true),
-    _useState4 = _slicedToArray(_useState3, 2),
-    isContextIdUnsync = _useState4[0],
-    setIsContextIdUnsync = _useState4[1];
-  useEffect(function () {
-    var mediaNodeUpdater = createMediaNodeUpdater(props);
-    mediaNodeUpdater.hasDifferentContextId().then(setIsContextIdUnsync);
-    handleNewNode(props);
-    updateMediaNodeAttributes(props, mediaNodeUpdater);
-    updateViewMediaClientConfig(props);
-    return function () {
-      var mediaPluginState = props.mediaPluginState;
-      mediaPluginState.handleMediaNodeUnmount(props.node);
-    };
-  }, [props]);
-  var updateViewMediaClientConfig = /*#__PURE__*/function () {
-    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(props) {
-      var mediaProvider, _viewMediaClientConfig;
-      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
-          case 0:
-            _context2.next = 2;
-            return props.mediaProvider;
-          case 2:
-            mediaProvider = _context2.sent;
-            if (mediaProvider) {
-              _viewMediaClientConfig = mediaProvider.viewMediaClientConfig;
-              setViewMediaClientConfig(_viewMediaClientConfig);
-            }
-          case 4:
-          case "end":
-            return _context2.stop();
-        }
-      }, _callee2);
-    }));
-    return function updateViewMediaClientConfig(_x3) {
-      return _ref2.apply(this, arguments);
-    };
-  }();
-  var _props$node$attrs = props.node.attrs,
-    id = _props$node$attrs.id,
-    collection = _props$node$attrs.collection;
-  var identifier = {
-    id: id,
-    mediaItemType: 'file',
-    collectionName: collection
-  };
-
-  /*
-   * Show the loading view if
-   * 1. The media provider is not ready
-   * 2. Context Id is not synced
-   * to prevent calling the media API (in mounting of `MediaInlineCard`)
-   * before the prerequisites meet
-   */
-  if (!viewMediaClientConfig || isContextIdUnsync) {
-    return /*#__PURE__*/React.createElement(MediaInlineCardLoadingView, {
-      message: "",
-      isSelected: false
-    });
-  }
-  return /*#__PURE__*/React.createElement(MediaInlineCard, {
-    isSelected: props.isSelected,
-    identifier: identifier,
-    mediaClientConfig: viewMediaClientConfig
-  });
-};
-var MediaInlineSharedState = function MediaInlineSharedState(_ref3) {
-  var identifier = _ref3.identifier,
-    mediaProvider = _ref3.mediaProvider,
-    node = _ref3.node,
-    isSelected = _ref3.isSelected,
-    getPos = _ref3.getPos,
-    contextIdentifierProvider = _ref3.contextIdentifierProvider,
-    api = _ref3.api,
-    view = _ref3.view;
-  var _useSharedPluginState = useSharedPluginState(api, ['media']),
-    mediaState = _useSharedPluginState.mediaState;
-  if (!mediaState) {
-    return null;
-  }
-  return /*#__PURE__*/React.createElement(MediaInline, {
-    identifier: identifier,
-    mediaProvider: mediaProvider,
-    mediaPluginState: mediaState,
-    node: node,
-    isSelected: isSelected,
-    view: view,
-    getPos: getPos,
-    contextIdentifierProvider: contextIdentifierProvider
-  });
-};
-export var MediaInlineNodeView = /*#__PURE__*/function (_SelectionBasedNodeVi) {
-  _inherits(MediaInlineNodeView, _SelectionBasedNodeVi);
-  var _super = _createSuper(MediaInlineNodeView);
-  function MediaInlineNodeView() {
-    _classCallCheck(this, MediaInlineNodeView);
-    return _super.apply(this, arguments);
-  }
-  _createClass(MediaInlineNodeView, [{
-    key: "createDomRef",
-    value: function createDomRef() {
-      var domRef = document.createElement('span');
-      domRef.contentEditable = 'false';
-      return domRef;
-    }
-  }, {
-    key: "getContentDOM",
-    value: function getContentDOM() {
-      var dom = document.createElement('span');
-      dom.classList.add(MediaInlineNodeSelector);
-      return {
-        dom: dom
-      };
-    }
-  }, {
-    key: "ignoreMutation",
-    value: function ignoreMutation() {
-      return true;
-    }
-  }, {
-    key: "viewShouldUpdate",
-    value: function viewShouldUpdate(nextNode) {
-      if (this.node.attrs !== nextNode.attrs) {
-        return true;
-      }
-      return _get(_getPrototypeOf(MediaInlineNodeView.prototype), "viewShouldUpdate", this).call(this, nextNode);
-    }
-  }, {
-    key: "render",
-    value: function render(props) {
-      var _this = this;
-      var providerFactory = props.providerFactory,
-        api = props.api;
-      var view = this.view;
-      var getPos = this.getPos;
-      return /*#__PURE__*/React.createElement(WithProviders, {
-        providers: ['mediaProvider', 'contextIdentifierProvider'],
-        providerFactory: providerFactory,
-        renderNode: function renderNode(_ref4) {
-          var mediaProvider = _ref4.mediaProvider,
-            contextIdentifierProvider = _ref4.contextIdentifierProvider;
-          if (!mediaProvider) {
-            return null;
-          }
-          return /*#__PURE__*/React.createElement(MediaInlineSharedState, {
-            identifier: _this.node.attrs.id,
-            mediaProvider: mediaProvider,
-            node: _this.node,
-            isSelected: _this.nodeInsideSelection(),
-            view: view,
-            getPos: getPos,
-            contextIdentifierProvider: contextIdentifierProvider,
-            api: api
-          });
-        }
-      });
-    }
-  }]);
-  return MediaInlineNodeView;
-}(SelectionBasedNodeView);
-export var ReactMediaInlineNode = function ReactMediaInlineNode(portalProviderAPI, eventDispatcher, providerFactory, api, dispatchAnalyticsEvent) {
-  return function (node, view, getPos) {
-    return new MediaInlineNodeView(node, view, getPos, portalProviderAPI, eventDispatcher, {
-      providerFactory: providerFactory,
-      dispatchAnalyticsEvent: dispatchAnalyticsEvent,
-      api: api
-    }).init();
-  };
-};