@atlaskit/editor-common 69.2.1 → 69.3.0

package/dist/cjs/with-plugin-state/index.js

@@ -0,0 +1,316 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WithPluginState = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+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) { (0, _defineProperty2.default)(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; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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; } }
+
+var DEFAULT_SAMPLING_RATE = 100;
+var DEFAULT_SLOW_THRESHOLD = 4;
+
+/**
+ * Wraps component in a high order component that watches state changes of given plugins
+ * and passes those states to the wrapped component.
+ *
+ * Example:
+ * <WithPluginState
+ *   eventDispatcher={eventDispatcher}
+ *   editorView={editorView}
+ *   plugins={{
+ *     hyperlink: hyperlinkPluginKey
+ *   }}
+ *   render={renderComponent}
+ * />
+ *
+ * renderComponent: ({ hyperlink }) => React.Component;
+ */
+var WithPluginState = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2.default)(WithPluginState, _React$Component);
+
+  var _super = _createSuper(WithPluginState);
+
+  function WithPluginState() {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, WithPluginState);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "listeners", {});
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "debounce", null);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "notAppliedState", {});
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "isSubscribed", false);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "state", _this.getPluginsStates(_this.props.plugins, _this.getEditorView(_this.props, _this.context)));
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "handlePluginStateChange", function (propName, pluginName, performanceOptions, skipEqualityCheck) {
+      return function (pluginState) {
+        // skipEqualityCheck is being used for old plugins since they are mutating plugin state instead of creating a new one
+        if (_this.state[propName] !== pluginState || skipEqualityCheck) {
+          _this.updateState({
+            stateSubset: (0, _defineProperty2.default)({}, propName, pluginState),
+            pluginName: pluginName,
+            performanceOptions: performanceOptions
+          });
+        }
+      };
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "updateState", function (_ref) {
+      var stateSubset = _ref.stateSubset,
+          pluginName = _ref.pluginName,
+          performanceOptions = _ref.performanceOptions;
+      _this.notAppliedState = _objectSpread(_objectSpread({}, _this.notAppliedState), stateSubset);
+
+      if (_this.debounce) {
+        window.clearTimeout(_this.debounce);
+      }
+
+      var debounce = _this.props.debounce !== false ? function (fn) {
+        return window.setTimeout(fn, 0);
+      } : function (fn) {
+        return fn();
+      };
+      _this.debounce = debounce(function () {
+        // TODO: ED-15580
+        //const measure = `🦉${pluginName}::WithPluginState`;
+        //performanceOptions.trackingEnabled && startMeasure(measure);
+        //              () => {
+        //  performanceOptions.trackingEnabled &&
+        //    stopMeasure(measure, (duration) => {
+        //      // Each WithPluginState component will fire analytics event no more than once every `samplingLimit` times
+        //      if (
+        //        ++this.callsCount % performanceOptions.samplingRate === 0 &&
+        //        duration > performanceOptions.slowThreshold
+        //      ) {
+        //        const editorView = this.getEditorView();
+        //        this.dispatchAnalyticsEvent({
+        //          action: ACTION.WITH_PLUGIN_STATE_CALLED,
+        //          actionSubject: ACTION_SUBJECT.EDITOR,
+        //          eventType: EVENT_TYPE.OPERATIONAL,
+        //          attributes: {
+        //            plugin: pluginName,
+        //            duration,
+        //            participants: getParticipantsCount(
+        //              editorView && editorView.state,
+        //            ),
+        //          },
+        //        });
+        //      }
+        //    });
+        //}
+        _this.setState(_this.notAppliedState);
+
+        _this.debounce = null;
+        _this.notAppliedState = {};
+      });
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "onContextUpdate", function () {
+      _this.subscribe(_this.props);
+    });
+    return _this;
+  }
+
+  (0, _createClass2.default)(WithPluginState, [{
+    key: "getEditorView",
+    value: function getEditorView(maybeProps, maybeContext) {
+      var props = maybeProps || this.props;
+      var context = maybeContext || this.context;
+      return props.editorView || context && context.editorActions && context.editorActions._privateGetEditorView() || context && context.editorSharedConfig && context.editorSharedConfig.editorView;
+    }
+  }, {
+    key: "getEventDispatcher",
+    value: function getEventDispatcher(maybeProps) {
+      var props = maybeProps || this.props;
+      return props.eventDispatcher || this.context && this.context.editorActions && this.context.editorActions._privateGetEventDispatcher() || this.context && this.context.editorSharedConfig && this.context.editorSharedConfig.eventDispatcher;
+    }
+  }, {
+    key: "getPluginsStates",
+    value: // TODO: ED-15580
+    //private dispatchAnalyticsEvent = (payload: AnalyticsEventPayload) => {
+    //  const eventDispatcher = this.getEventDispatcher();
+    //  if (eventDispatcher) {
+    //    const dispatch: AnalyticsDispatch = createDispatch(eventDispatcher);
+    //    dispatch(analyticsEventKey, {
+    //      payload,
+    //    });
+    //  }
+    //};
+    function getPluginsStates(plugins, editorView) {
+      if (!editorView || !plugins) {
+        return {};
+      }
+
+      var keys = Object.keys(plugins);
+      return keys.reduce(function (acc, propName) {
+        var pluginKey = plugins[propName];
+
+        if (!pluginKey) {
+          return acc;
+        }
+
+        acc[propName] = pluginKey.getState(editorView.state);
+        return acc;
+      }, {});
+    }
+  }, {
+    key: "subscribe",
+    value: function subscribe(props) {
+      var _this2 = this;
+
+      var plugins = props.plugins;
+      var eventDispatcher = this.getEventDispatcher(props);
+      var editorView = this.getEditorView(props);
+
+      if (!eventDispatcher || !editorView || this.isSubscribed) {
+        return;
+      } // TODO: ED-15580
+      //const analyticsPlugin = analyticsPluginKey.getState(editorView.state);
+      //const uiTracking =
+      //  analyticsPlugin && analyticsPlugin.performanceTracking
+      //    ? analyticsPlugin.performanceTracking.uiTracking || {}
+      //    : {};
+      //const trackingEnabled = uiTracking.enabled === true;
+      //const samplingRate = uiTracking.samplingRate || DEFAULT_SAMPLING_RATE;
+      //const slowThreshold = uiTracking.slowThreshold || DEFAULT_SLOW_THRESHOLD;
+
+
+      var trackingEnabled = false;
+      var samplingRate = DEFAULT_SAMPLING_RATE;
+      var slowThreshold = DEFAULT_SLOW_THRESHOLD;
+      this.isSubscribed = true;
+      var pluginsStates = this.getPluginsStates(plugins, editorView);
+      this.setState(pluginsStates);
+      Object.keys(plugins).forEach(function (propName) {
+        var pluginKey = plugins[propName];
+
+        if (!pluginKey) {
+          return;
+        }
+
+        var pluginName = pluginKey.key;
+        var pluginState = pluginsStates[propName];
+        var isPluginWithSubscribe = pluginState && pluginState.subscribe;
+
+        var handler = _this2.handlePluginStateChange(propName, pluginName, {
+          samplingRate: samplingRate,
+          slowThreshold: slowThreshold,
+          trackingEnabled: trackingEnabled
+        }, isPluginWithSubscribe);
+
+        if (isPluginWithSubscribe) {
+          pluginState.subscribe(handler);
+        } else {
+          eventDispatcher.on(pluginKey.key, handler);
+        }
+
+        _this2.listeners[pluginKey.key] = {
+          handler: handler,
+          pluginKey: pluginKey
+        };
+      });
+    }
+  }, {
+    key: "unsubscribe",
+    value: function unsubscribe() {
+      var _this3 = this;
+
+      var eventDispatcher = this.getEventDispatcher();
+      var editorView = this.getEditorView();
+
+      if (!eventDispatcher || !editorView || !this.isSubscribed) {
+        return;
+      }
+
+      Object.keys(this.listeners).forEach(function (key) {
+        var pluginState = _this3.listeners[key].pluginKey.getState(editorView.state);
+
+        if (pluginState && pluginState.unsubscribe) {
+          pluginState.unsubscribe(_this3.listeners[key].handler);
+        } else {
+          eventDispatcher.off(key, _this3.listeners[key].handler);
+        }
+      });
+      this.listeners = [];
+    }
+  }, {
+    key: "subscribeToContextUpdates",
+    value: function subscribeToContextUpdates(context) {
+      if (context && context.editorActions) {
+        context.editorActions._privateSubscribe(this.onContextUpdate);
+      }
+    }
+  }, {
+    key: "unsubscribeFromContextUpdates",
+    value: function unsubscribeFromContextUpdates(context) {
+      if (context && context.editorActions) {
+        context.editorActions._privateUnsubscribe(this.onContextUpdate);
+      }
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.subscribe(this.props);
+      this.subscribeToContextUpdates(this.context);
+    }
+  }, {
+    key: "UNSAFE_componentWillReceiveProps",
+    value: function UNSAFE_componentWillReceiveProps(nextProps) {
+      if (!this.isSubscribed) {
+        this.subscribe(nextProps);
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.debounce) {
+        window.clearTimeout(this.debounce);
+      }
+
+      this.unsubscribeFromContextUpdates(this.context);
+      this.unsubscribe();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var render = this.props.render;
+      return render(this.state);
+    }
+  }]);
+  return WithPluginState;
+}(_react.default.Component);
+
+exports.WithPluginState = WithPluginState;
+(0, _defineProperty2.default)(WithPluginState, "displayName", 'WithPluginState');
+(0, _defineProperty2.default)(WithPluginState, "contextTypes", {
+  editorActions: _propTypes.default.object,
+  editorSharedConfig: _propTypes.default.object
+});

package/dist/cjs/with-plugin-state/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/es2019/__tests_external__/cases/fundamentals/collection.js

@@ -0,0 +1,7 @@
+import { InProductTestCollection } from '@atlaskit/in-product-testing';
+import { editorIsPresentTestCase } from './test-cases/editor-is-present';
+import { editorTypingTestCase } from './test-cases/editor-typing';
+export const fundamentalsTestCollection = opts => new InProductTestCollection({
+  title: '@atlaskit/editor-core -> Editor fundamentals happy path tests',
+  testCases: [editorIsPresentTestCase(opts), editorTypingTestCase(opts)]
+});

package/dist/es2019/__tests_external__/cases/fundamentals/test-cases/editor-is-present.js

@@ -0,0 +1,12 @@
+import { InProductTestCase } from '@atlaskit/in-product-testing';
+import { EditorPageObject } from '../../../page-objects/Editor';
+export const editorIsPresentTestCase = testOptions => new InProductTestCase({
+  testOptions,
+  title: 'content-area, title of Editor are visible',
+  id: 'editor-is-present',
+  assertions: cy => {
+    const editor = new EditorPageObject(cy);
+    editor.getTitleArea().should('be.visible');
+    editor.getEditorArea().should('be.visible');
+  }
+});

package/dist/es2019/__tests_external__/cases/fundamentals/test-cases/editor-typing.js

@@ -0,0 +1,25 @@
+import { InProductTestCase } from '@atlaskit/in-product-testing';
+import { EditorPageObject } from '../../../page-objects/Editor';
+import { RendererPageObject } from '../../../page-objects/Renderer';
+export const editorTypingTestCase = opts => new InProductTestCase({
+  title: 'typing in Editor works',
+  id: 'editor-typing',
+  assertions: cy => {
+    var _opts$ui;
+
+    const editor = new EditorPageObject(cy);
+    editor.getEditorArea().type('abcdef');
+    editor.getEditorArea().contains('abcdef');
+
+    if (!opts || !((_opts$ui = opts.ui) !== null && _opts$ui !== void 0 && _opts$ui.publishButton)) {
+      return;
+    }
+
+    const {
+      publishButton
+    } = opts.ui;
+    const renderer = new RendererPageObject(cy);
+    cy.get(publishButton).click();
+    renderer.getContent().contains('abcdef');
+  }
+});

package/dist/es2019/__tests_external__/cases/media/test-cases/alt-text.js

@@ -0,0 +1,29 @@
+import { InProductTestCase } from '@atlaskit/in-product-testing';
+import { MediaCardPageObject } from '@atlaskit/media-card/in-product';
+import { EditorPageObject } from '../../../page-objects/Editor';
+import { EditorMediaPageObject } from '../../../page-objects/EditorMedia';
+export const addAltTextMediaTestCase = ({
+  ui,
+  fixtures
+}) => new InProductTestCase({
+  title: 'adding alt text to Media works',
+  id: 'media-alt-text',
+  precondition: () => fixtures.length > 0,
+  assertions: cy => {
+    const editor = new EditorPageObject(cy);
+    const editorMedia = new EditorMediaPageObject(cy);
+    const mediaCard = new MediaCardPageObject(cy);
+    editor.upload(fixtures);
+    mediaCard.expectCardReady(fixtures.length);
+    const altText = 'Corne **loves** avocados';
+    editorMedia.addAltTextToImage(altText);
+    editorMedia.assertAltText(altText);
+
+    if (ui !== null && ui !== void 0 && ui.publishButton) {
+      const renderer = editor.publish(ui);
+      renderer.expectContentReady();
+      renderer.expectMediaSingleRenders(fixtures.length);
+      mediaCard.assertAltText(altText);
+    }
+  }
+});

package/dist/es2019/__tests_external__/cases/media/test-cases/caption.js

@@ -0,0 +1,28 @@
+import { InProductTestCase } from '@atlaskit/in-product-testing';
+import { MediaCardPageObject } from '@atlaskit/media-card/in-product';
+import { EditorPageObject } from '../../../page-objects/Editor';
+import { EditorMediaPageObject } from '../../../page-objects/EditorMedia';
+export const addCaptionMediaTestCase = ({
+  ui,
+  fixtures
+}) => new InProductTestCase({
+  title: 'adding caption to Media works',
+  id: 'media-caption',
+  precondition: () => fixtures.length > 0,
+  assertions: cy => {
+    const editor = new EditorPageObject(cy);
+    const editorMedia = new EditorMediaPageObject(cy);
+    const mediaCard = new MediaCardPageObject(cy);
+    editor.upload(fixtures);
+    mediaCard.expectCardReady(fixtures.length);
+    const captionText = 'Corne loves avocados';
+    editorMedia.addCaptionToImage(captionText);
+
+    if (ui !== null && ui !== void 0 && ui.publishButton) {
+      const renderer = editor.publish(ui);
+      renderer.expectContentReady();
+      renderer.expectMediaSingleRenders(fixtures.length);
+      editorMedia.assertCaptionText(captionText);
+    }
+  }
+});

package/dist/es2019/__tests_external__/cases/media/test-cases/index.js

@@ -0,0 +1,8 @@
+import { InProductTestCollection } from '@atlaskit/in-product-testing';
+import { addAltTextMediaTestCase } from './alt-text';
+import { addCaptionMediaTestCase } from './caption';
+import { uploadMediaTestCase } from './upload';
+export const mediaTestCollection = opts => new InProductTestCollection({
+  title: '@atlaskit/editor-core -> Media, happy paths',
+  testCases: [uploadMediaTestCase(opts), addAltTextMediaTestCase(opts), addCaptionMediaTestCase(opts)]
+});

package/dist/es2019/__tests_external__/cases/media/test-cases/types.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/__tests_external__/cases/media/test-cases/upload.js

@@ -0,0 +1,23 @@
+import { InProductTestCase } from '@atlaskit/in-product-testing';
+import { MediaCardPageObject } from '@atlaskit/media-card/in-product';
+import { EditorPageObject } from '../../../page-objects/Editor';
+export const uploadMediaTestCase = ({
+  ui,
+  fixtures
+}) => new InProductTestCase({
+  title: 'media upload and publish works',
+  id: 'media-file-upload',
+  precondition: () => fixtures.length > 0,
+  assertions: cy => {
+    const editor = new EditorPageObject(cy);
+    const mediaCard = new MediaCardPageObject(cy);
+    editor.upload(fixtures);
+    mediaCard.expectCardReady(fixtures.length);
+
+    if (ui !== null && ui !== void 0 && ui.publishButton) {
+      const renderer = editor.publish(ui);
+      renderer.expectContentReady();
+      renderer.expectMediaSingleRenders(fixtures.length);
+    }
+  }
+});

package/dist/es2019/__tests_external__/cases/smart-links/index.js

@@ -0,0 +1,4 @@
+export { inlineSmartLinksTestCollection } from './test-cases/inline';
+export { blockSmartLinksTestCollection } from './test-cases/block';
+export { embedSmartLinksTestCollection } from './test-cases/embed';
+export { blueLinksTestCollection } from './test-cases/url';

package/dist/es2019/__tests_external__/cases/smart-links/test-cases/block/delete.js

@@ -0,0 +1,29 @@
+import { InProductTestCase } from '@atlaskit/in-product-testing';
+import { BlockCardPageObject, blockSmartLinkRendersTestCase } from '@atlaskit/smart-card/in-product';
+import { EditorPageObject } from '../../../../page-objects/Editor';
+import { EditorSmartLinkPageObject } from '../../../../page-objects/EditorSmartLink';
+export const deleteBlockSmartLinkTestCase = ({
+  ui,
+  url
+}) => new InProductTestCase({
+  title: 'able to delete a Block Smart Link using floating toolbar',
+  id: 'delete-block-smart-link',
+  assertions: cy => {
+    const editor = new EditorPageObject(cy);
+    const editorWithSmartLinks = new EditorSmartLinkPageObject(cy, editor);
+    const blockCard = new BlockCardPageObject(cy);
+    editorWithSmartLinks.insertSmartLinkByTyping(url);
+    editorWithSmartLinks.switchAfterInsert('block');
+    blockSmartLinkRendersTestCase({
+      url
+    }).assertions(cy);
+    editorWithSmartLinks.deleteSmartLink('block');
+    blockCard.expectCardNotExists();
+
+    if (ui !== null && ui !== void 0 && ui.publishButton) {
+      const renderer = editor.publish(ui);
+      renderer.expectContentReady();
+      blockCard.expectCardNotExists();
+    }
+  }
+});

package/dist/es2019/__tests_external__/cases/smart-links/test-cases/block/edit.js

@@ -0,0 +1,59 @@
+import { InProductTestCase } from '@atlaskit/in-product-testing';
+import { BlockCardPageObject, blockSmartLinkRendersTestCase } from '@atlaskit/smart-card/in-product';
+import { EditorPageObject } from '../../../../page-objects/Editor';
+import { EditorSmartLinkPageObject } from '../../../../page-objects/EditorSmartLink';
+export const editBlockSmartLinkTitleTestCase = ({
+  ui,
+  url
+}) => new InProductTestCase({
+  title: 'editing a Block Smart Link renders as Blue Link (title)',
+  id: 'block-smart-link-edit-title',
+  assertions: cy => {
+    const editor = new EditorPageObject(cy);
+    const editorWithSmartLinks = new EditorSmartLinkPageObject(cy, editor);
+    const blockCard = new BlockCardPageObject(cy);
+    editorWithSmartLinks.insertSmartLinkByTyping(url);
+    editorWithSmartLinks.switchAfterInsert('block');
+    blockSmartLinkRendersTestCase({
+      url
+    }).assertions(cy);
+    editorWithSmartLinks.changeLinkLabel('Avocorne is watching you 🥑', 'block');
+    blockCard.assertHrefRendered(url);
+    blockCard.expectCardNotExists();
+
+    if (ui !== null && ui !== void 0 && ui.publishButton) {
+      const renderer = editor.publish(ui);
+      renderer.expectContentReady();
+      blockCard.assertHrefRendered(url);
+      blockCard.expectCardNotExists();
+    }
+  }
+});
+export const editBlockSmartLinkUrlTestCase = ({
+  ui,
+  url
+}) => new InProductTestCase({
+  title: 'editing a Block Smart Link renders as Blue Link (URL)',
+  id: 'block-smart-link-edit',
+  assertions: cy => {
+    const editor = new EditorPageObject(cy);
+    const editorWithSmartLinks = new EditorSmartLinkPageObject(cy, editor);
+    const blockCard = new BlockCardPageObject(cy);
+    editorWithSmartLinks.insertSmartLinkByTyping(url);
+    editorWithSmartLinks.switchAfterInsert('block');
+    blockSmartLinkRendersTestCase({
+      url
+    }).assertions(cy);
+    const newUrl = 'https://avo.corne.com';
+    editorWithSmartLinks.changeLinkUrl(newUrl, 'block');
+    blockCard.expectCardNotExists();
+    blockCard.assertHrefRendered(newUrl);
+
+    if (ui !== null && ui !== void 0 && ui.publishButton) {
+      const renderer = editor.publish(ui);
+      renderer.expectContentReady();
+      blockCard.assertHrefRendered(newUrl);
+      blockCard.expectCardNotExists();
+    }
+  }
+});

package/dist/es2019/__tests_external__/cases/smart-links/test-cases/block/index.js

@@ -0,0 +1,8 @@
+import { InProductTestCollection } from '@atlaskit/in-product-testing';
+import { deleteBlockSmartLinkTestCase } from './delete';
+import { editBlockSmartLinkTitleTestCase, editBlockSmartLinkUrlTestCase } from './edit';
+import { switchToBlockSmartLinkTestCase } from './insert';
+export const blockSmartLinksTestCollection = opts => new InProductTestCollection({
+  title: '@atlaskit/editor-core -> Block Smart Links, happy paths',
+  testCases: [switchToBlockSmartLinkTestCase(opts), editBlockSmartLinkTitleTestCase(opts), editBlockSmartLinkUrlTestCase(opts), deleteBlockSmartLinkTestCase(opts)]
+});

package/dist/es2019/__tests_external__/cases/smart-links/test-cases/block/insert.js

@@ -0,0 +1,28 @@
+import { InProductTestCase } from '@atlaskit/in-product-testing';
+import { blockSmartLinkRendersTestCase } from '@atlaskit/smart-card/in-product';
+import { EditorPageObject } from '../../../../page-objects/Editor';
+import { EditorSmartLinkPageObject } from '../../../../page-objects/EditorSmartLink';
+export const switchToBlockSmartLinkTestCase = ({
+  ui,
+  url
+}) => new InProductTestCase({
+  title: 'switching to a Block Smart Link works',
+  id: 'switch-to-block',
+  assertions: cy => {
+    const editor = new EditorPageObject(cy);
+    const editorWithSmartLinks = new EditorSmartLinkPageObject(cy, editor);
+    editorWithSmartLinks.insertSmartLinkByTyping(url);
+    editorWithSmartLinks.switchAfterInsert('block');
+    blockSmartLinkRendersTestCase({
+      url
+    }).assertions(cy);
+
+    if (ui !== null && ui !== void 0 && ui.publishButton) {
+      const renderer = editor.publish(ui);
+      renderer.expectContentReady();
+      blockSmartLinkRendersTestCase({
+        url
+      }).assertions(cy);
+    }
+  }
+});

package/dist/es2019/__tests_external__/cases/smart-links/test-cases/embed/delete.js

@@ -0,0 +1,29 @@
+import { InProductTestCase } from '@atlaskit/in-product-testing';
+import { EmbedCardPageObject, embedSmartLinkRendersTestCase } from '@atlaskit/smart-card/in-product';
+import { EditorPageObject } from '../../../../page-objects/Editor';
+import { EditorSmartLinkPageObject } from '../../../../page-objects/EditorSmartLink';
+export const deleteEmbedSmartLinkTestCase = ({
+  ui,
+  url
+}) => new InProductTestCase({
+  title: 'able to delete an Embed Smart Link using floating toolbar',
+  id: 'delete-embed-smart-link',
+  assertions: cy => {
+    const editor = new EditorPageObject(cy);
+    const editorWithSmartLinks = new EditorSmartLinkPageObject(cy, editor);
+    const embedCard = new EmbedCardPageObject(cy);
+    editorWithSmartLinks.insertSmartLinkByTyping(url);
+    editorWithSmartLinks.switchAfterInsert('embed');
+    embedSmartLinkRendersTestCase({
+      url
+    }).assertions(cy);
+    editorWithSmartLinks.deleteSmartLink('embed');
+    embedCard.expectCardNotExists();
+
+    if (ui !== null && ui !== void 0 && ui.publishButton) {
+      const renderer = editor.publish(ui);
+      renderer.expectContentReady();
+      embedCard.expectCardNotExists();
+    }
+  }
+});