@atlaskit/editor-core 180.0.0 → 181.0.0

package/dist/esm/create-editor/ReactEditorViewNext.js

@@ -0,0 +1,7 @@
+import React from 'react';
+import { ReactEditorView } from './ReactEditorViewInternal';
+import { injectIntl } from 'react-intl-next';
+export function ReactEditorViewEditor(props) {
+  return /*#__PURE__*/React.createElement(ReactEditorView, props);
+}
+export default injectIntl(ReactEditorViewEditor);

package/dist/esm/create-editor/create-plugins-list.js

@@ -83,6 +83,7 @@ export function getDefaultPresetOptionsFromEditorProps(props, createAnalyticsEve
     },
     cardOptions: cardOptions,
     hyperlinkOptions: {
+      editorAppearance: props.appearance,
       linkPicker: (_props$linking2 = props.linking) === null || _props$linking2 === void 0 ? void 0 : _props$linking2.linkPicker,
       cardOptions: cardOptions,
       platform: isMobile ? 'mobile' : 'web'
@@ -101,13 +102,39 @@ export function getDefaultPresetOptionsFromEditorProps(props, createAnalyticsEve
  * Note: The order that presets are added determines
  * their placement in the editor toolbar
  */
-export default function createPluginsList(props, prevProps, createAnalyticsEvent, insertNodeAPI, editorAnalyticsAPI, editorSelectionAPI, getEditorContainerWidth) {
-  var preset = createUniversalPreset(props.appearance, getDefaultPresetOptionsFromEditorProps(props, createAnalyticsEvent), createFeatureFlagsFromProps(props), prevProps === null || prevProps === void 0 ? void 0 : prevProps.appearance, createAnalyticsEvent, insertNodeAPI, editorAnalyticsAPI, editorSelectionAPI, getEditorContainerWidth);
+export default function createPluginsList(props, prevProps, createAnalyticsEvent) {
+  var preset = createUniversalPreset(props.appearance, getDefaultPresetOptionsFromEditorProps(props, createAnalyticsEvent), createFeatureFlagsFromProps(props), prevProps === null || prevProps === void 0 ? void 0 : prevProps.appearance, createAnalyticsEvent);
   var excludes = new Set();
   if (!isCodeBlockAllowed({
     allowBlockType: props.allowBlockType
   })) {
     excludes.add('codeBlock');
   }
-  return preset.getEditorPlugins(excludes);
+  return preset.build({
+    excludePlugins: excludes
+  });
+}
+function withDangerouslyAppendPlugins(preset) {
+  function createEditorNextPluginsFromDangerouslyAppended(plugins) {
+    return plugins ? plugins.map(function (plugin) {
+      return function () {
+        return plugin;
+      };
+    }) : [];
+  }
+  return function (editorPluginsToAppend) {
+    if (!editorPluginsToAppend || editorPluginsToAppend.length === 0) {
+      return preset;
+    }
+    var nextEditorPluginsToAppend = createEditorNextPluginsFromDangerouslyAppended(editorPluginsToAppend);
+    var presetWithAppendedPlugins = nextEditorPluginsToAppend.reduce(function (acc, plugin) {
+      return acc.add(plugin);
+    }, preset);
+    return presetWithAppendedPlugins;
+  };
+}
+export function createPreset(props, prevProps, createAnalyticsEvent) {
+  var _props$dangerouslyApp;
+  var preset = createUniversalPreset(props.appearance, getDefaultPresetOptionsFromEditorProps(props, createAnalyticsEvent), createFeatureFlagsFromProps(props), prevProps === null || prevProps === void 0 ? void 0 : prevProps.appearance, createAnalyticsEvent);
+  return withDangerouslyAppendPlugins(preset)((_props$dangerouslyApp = props.dangerouslyAppendPlugins) === null || _props$dangerouslyApp === void 0 ? void 0 : _props$dangerouslyApp.__plugins);
 }

package/dist/esm/create-editor/feature-flags-from-props.js

@@ -25,7 +25,7 @@ function getSpellCheck(featureFlags) {
  * which is used by both current and archv3 editors.
  */
 export function createFeatureFlagsFromProps(props) {
-  var _props$featureFlags, _props$allowLayouts, _props$performanceTra, _props$performanceTra2, _props$featureFlags2, _props$featureFlags3, _props$allowTables, _props$featureFlags4, _props$featureFlags5, _props$allowTables2, _props$featureFlags6, _props$featureFlags7, _props$allowTables3, _props$featureFlags8, _props$featureFlags9, _props$allowTables4, _props$allowTables5, _props$featureFlags10, _props$featureFlags11, _props$allowTables6, _props$allowExtension, _props$featureFlags12, _props$featureFlags13, _props$featureFlags14, _props$featureFlags15, _props$featureFlags16, _props$featureFlags17, _props$featureFlags18, _props$featureFlags19, _props$featureFlags20, _props$featureFlags21, _props$featureFlags22, _props$featureFlags23, _props$featureFlags24, _props$featureFlags25, _props$featureFlags26, _props$featureFlags27, _props$featureFlags28, _props$featureFlags29, _props$collabEdit, _props$collabEdit2, _props$featureFlags30, _props$featureFlags31, _props$featureFlags32, _props$featureFlags33, _props$featureFlags34, _props$featureFlags35, _props$featureFlags36, _props$featureFlags37, _props$featureFlags38, _props$featureFlags39, _props$featureFlags40, _props$featureFlags41, _props$featureFlags42, _props$featureFlags43, _props$featureFlags44;
+  var _props$featureFlags, _props$allowLayouts, _props$performanceTra, _props$performanceTra2, _props$featureFlags2, _props$featureFlags3, _props$allowTables, _props$featureFlags4, _props$featureFlags5, _props$allowTables2, _props$featureFlags6, _props$featureFlags7, _props$allowTables3, _props$featureFlags8, _props$featureFlags9, _props$allowTables4, _props$allowTables5, _props$featureFlags10, _props$featureFlags11, _props$allowTables6, _props$allowExtension, _props$featureFlags12, _props$featureFlags13, _props$featureFlags14, _props$featureFlags15, _props$featureFlags16, _props$featureFlags17, _props$featureFlags18, _props$featureFlags19, _props$featureFlags20, _props$featureFlags21, _props$featureFlags22, _props$featureFlags23, _props$featureFlags24, _props$featureFlags25, _props$featureFlags26, _props$featureFlags27, _props$featureFlags28, _props$featureFlags29, _props$collabEdit, _props$collabEdit2, _props$featureFlags30, _props$featureFlags31, _props$featureFlags32, _props$featureFlags33, _props$featureFlags34, _props$featureFlags35, _props$featureFlags36, _props$featureFlags37, _props$featureFlags38, _props$featureFlags39, _props$featureFlags40, _props$featureFlags41, _props$featureFlags42, _props$featureFlags43, _props$featureFlags44, _props$featureFlags45;
   var normalizedFeatureFlags = normalizeFeatureFlags(props.featureFlags);
   var tableCellOptionsInFloatingToolbar = normalizedFeatureFlags.tableCellOptionsInFloatingToolbar || ((_props$featureFlags = props.featureFlags) === null || _props$featureFlags === void 0 ? void 0 : _props$featureFlags.tableCellOptionsInFloatingToolbar) || undefined;
   return _objectSpread(_objectSpread({}, normalizedFeatureFlags), {}, {
@@ -68,6 +68,7 @@ export function createFeatureFlagsFromProps(props) {
     restartNumberedListsToolbar: normalizedFeatureFlags.restartNumberedListsToolbar === true || ((_props$featureFlags40 = props.featureFlags) === null || _props$featureFlags40 === void 0 ? void 0 : _props$featureFlags40.restartNumberedListsToolbar) === true,
     useSomewhatSemanticTextColorNames: Boolean(typeof normalizedFeatureFlags.useSomewhatSemanticTextColorNames === 'boolean' && !!normalizedFeatureFlags.useSomewhatSemanticTextColorNames || (typeof ((_props$featureFlags41 = props.featureFlags) === null || _props$featureFlags41 === void 0 ? void 0 : _props$featureFlags41.useSomewhatSemanticTextColorNames) === 'boolean' ? !!((_props$featureFlags42 = props.featureFlags) !== null && _props$featureFlags42 !== void 0 && _props$featureFlags42.useSomewhatSemanticTextColorNames) : false)),
     lpLinkPickerFocusTrap: Boolean(normalizedFeatureFlags.lpLinkPickerFocusTrap),
-    preventPopupOverflow: Boolean(typeof ((_props$featureFlags43 = props.featureFlags) === null || _props$featureFlags43 === void 0 ? void 0 : _props$featureFlags43['prevent-popup-overflow']) === 'boolean' ? !!((_props$featureFlags44 = props.featureFlags) !== null && _props$featureFlags44 !== void 0 && _props$featureFlags44['prevent-popup-overflow']) : false)
+    preventPopupOverflow: Boolean(typeof ((_props$featureFlags43 = props.featureFlags) === null || _props$featureFlags43 === void 0 ? void 0 : _props$featureFlags43['prevent-popup-overflow']) === 'boolean' ? !!((_props$featureFlags44 = props.featureFlags) !== null && _props$featureFlags44 !== void 0 && _props$featureFlags44['prevent-popup-overflow']) : false),
+    useEditorNext: normalizedFeatureFlags.useEditorNext === true || ((_props$featureFlags45 = props.featureFlags) === null || _props$featureFlags45 === void 0 ? void 0 : _props$featureFlags45.useEditorNext) === true
   });
 }

package/dist/esm/create-editor/preset-utils.js

@@ -0,0 +1,21 @@
+var EMPTY = [];
+export function shouldRecreatePreset(props, nextProps) {
+  var _props$dangerouslyApp, _props$dangerouslyApp2, _nextProps$dangerousl, _nextProps$dangerousl2;
+  var prevPlugins = (_props$dangerouslyApp = (_props$dangerouslyApp2 = props.dangerouslyAppendPlugins) === null || _props$dangerouslyApp2 === void 0 ? void 0 : _props$dangerouslyApp2.__plugins) !== null && _props$dangerouslyApp !== void 0 ? _props$dangerouslyApp : EMPTY;
+  var nextPlugins = (_nextProps$dangerousl = (_nextProps$dangerousl2 = nextProps.dangerouslyAppendPlugins) === null || _nextProps$dangerousl2 === void 0 ? void 0 : _nextProps$dangerousl2.__plugins) !== null && _nextProps$dangerousl !== void 0 ? _nextProps$dangerousl : EMPTY;
+  if (nextPlugins.length !== prevPlugins.length || prevPlugins.some(function (p) {
+    return nextPlugins.some(function (n) {
+      return n.name === p.name && n !== p;
+    });
+  })) {
+    return true;
+  }
+  return shouldReconfigureState(props, nextProps);
+}
+function shouldReconfigureState(props, nextProps) {
+  var mobileProperties = props.appearance === 'mobile' ? ['quickInsert', 'featureFlags'] : [];
+  var properties = ['appearance', 'persistScrollGutter', 'allowUndoRedoButtons', 'placeholder', 'sanitizePrivateContent'].concat(mobileProperties);
+  return properties.reduce(function (acc, curr) {
+    return acc || props[curr] !== nextProps[curr];
+  }, false);
+}

package/dist/esm/editor-next/editor-internal.js

@@ -0,0 +1,141 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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; }
+/** @jsx jsx */
+
+import { BaseTheme, WidthProvider } from '@atlaskit/editor-common/ui';
+import { jsx, css } from '@emotion/react';
+import { Fragment } from 'react';
+import { getUiComponent } from '../create-editor';
+import ReactEditorView from '../create-editor/ReactEditorViewNext';
+import ErrorBoundary from '../create-editor/ErrorBoundary';
+import { createFeatureFlagsFromProps } from '../create-editor/feature-flags-from-props';
+import { ContextAdapter } from '../nodeviews/context-adapter';
+import { ACTION, ACTION_SUBJECT } from '@atlaskit/editor-common/analytics';
+import EditorContext from '../ui/EditorContext';
+import { PortalProviderWithThemeProviders, PortalRenderer } from '../ui/PortalProvider';
+import { RenderTracking } from '../utils/performance/components/RenderTracking';
+import { getBaseFontSize } from './utils/getBaseFontSize';
+import useMeasureEditorMountTime from './hooks/useMeasureEditorMountTime';
+import useProviderFactory from './hooks/useProviderFactory';
+/**
+ * EditorInternal is used for the internal editor react component
+ * with the lifecycle methods extracted into hooks.
+ */
+export default function EditorInternal(props) {
+  var editorProps = props.props,
+    getExperienceStore = props.getExperienceStore,
+    editorActions = props.editorActions,
+    createAnalyticsEvent = props.createAnalyticsEvent;
+  useMeasureEditorMountTime(editorProps, getExperienceStore, createAnalyticsEvent);
+  var providerFactory = useProviderFactory(editorProps, editorActions, createAnalyticsEvent);
+  var updatedProps = _objectSpread(_objectSpread({}, props), {}, {
+    providerFactory: providerFactory
+  });
+  return jsx(EditorInternalWithoutHooks, updatedProps);
+}
+
+/**
+ * EditorInternalComponent is used to capture the common component
+ * from the `render` method of `Editor` and share it with `EditorNext`.
+ */
+export function EditorInternalWithoutHooks(_ref) {
+  var _props$performanceTra, _props$performanceTra2;
+  var props = _ref.props,
+    handleAnalyticsEvent = _ref.handleAnalyticsEvent,
+    createAnalyticsEvent = _ref.createAnalyticsEvent,
+    handleSave = _ref.handleSave,
+    editorActions = _ref.editorActions,
+    providerFactory = _ref.providerFactory,
+    onEditorCreated = _ref.onEditorCreated,
+    onEditorDestroyed = _ref.onEditorDestroyed,
+    preset = _ref.preset;
+  var Component = getUiComponent(props.appearance);
+  var overriddenEditorProps = _objectSpread(_objectSpread({}, props), {}, {
+    onSave: props.onSave ? handleSave : undefined,
+    // noop all analytic events, even if a handler is still passed.
+    analyticsHandler: undefined
+  });
+  var featureFlags = createFeatureFlagsFromProps(props);
+  var renderTracking = (_props$performanceTra = props.performanceTracking) === null || _props$performanceTra === void 0 ? void 0 : (_props$performanceTra2 = _props$performanceTra.renderTracking) === null || _props$performanceTra2 === void 0 ? void 0 : _props$performanceTra2.editor;
+  var renderTrackingEnabled = renderTracking === null || renderTracking === void 0 ? void 0 : renderTracking.enabled;
+  var useShallow = renderTracking === null || renderTracking === void 0 ? void 0 : renderTracking.useShallow;
+  return jsx(Fragment, null, renderTrackingEnabled && jsx(RenderTracking, {
+    componentProps: props,
+    action: ACTION.RE_RENDERED,
+    actionSubject: ACTION_SUBJECT.EDITOR,
+    handleAnalyticsEvent: handleAnalyticsEvent,
+    propsToIgnore: ['defaultValue'],
+    useShallow: useShallow
+  }), jsx(ErrorBoundary, {
+    createAnalyticsEvent: createAnalyticsEvent,
+    contextIdentifierProvider: props.contextIdentifierProvider
+  }, jsx(WidthProvider, {
+    css: css({
+      height: '100%'
+    })
+  }, jsx(EditorContext, {
+    editorActions: editorActions
+  }, jsx(ContextAdapter, null, jsx(PortalProviderWithThemeProviders, {
+    onAnalyticsEvent: handleAnalyticsEvent,
+    useAnalyticsContext: props.UNSAFE_useAnalyticsContext,
+    render: function render(portalProviderAPI) {
+      return jsx(Fragment, null, jsx(ReactEditorView, {
+        editorProps: overriddenEditorProps,
+        createAnalyticsEvent: createAnalyticsEvent,
+        portalProviderAPI: portalProviderAPI,
+        providerFactory: providerFactory,
+        onEditorCreated: onEditorCreated,
+        onEditorDestroyed: onEditorDestroyed,
+        allowAnalyticsGASV3: props.allowAnalyticsGASV3,
+        disabled: props.disabled,
+        preset: preset,
+        render: function render(_ref2) {
+          var _props$featureFlags, _props$featureFlags2;
+          var editor = _ref2.editor,
+            view = _ref2.view,
+            eventDispatcher = _ref2.eventDispatcher,
+            config = _ref2.config,
+            dispatchAnalyticsEvent = _ref2.dispatchAnalyticsEvent,
+            editorRef = _ref2.editorRef;
+          return jsx(BaseTheme, {
+            baseFontSize: getBaseFontSize(props.appearance)
+          }, jsx(Component, {
+            innerRef: editorRef,
+            appearance: props.appearance,
+            disabled: props.disabled,
+            editorActions: editorActions,
+            editorDOMElement: editor,
+            editorView: view,
+            providerFactory: providerFactory,
+            eventDispatcher: eventDispatcher,
+            dispatchAnalyticsEvent: dispatchAnalyticsEvent,
+            maxHeight: props.maxHeight,
+            minHeight: props.minHeight,
+            onSave: props.onSave ? handleSave : undefined,
+            onCancel: props.onCancel,
+            popupsMountPoint: props.popupsMountPoint,
+            popupsBoundariesElement: props.popupsBoundariesElement,
+            popupsScrollableElement: props.popupsScrollableElement,
+            contentComponents: config.contentComponents,
+            primaryToolbarComponents: config.primaryToolbarComponents,
+            primaryToolbarIconBefore: props.primaryToolbarIconBefore,
+            secondaryToolbarComponents: config.secondaryToolbarComponents,
+            insertMenuItems: props.insertMenuItems,
+            customContentComponents: props.contentComponents,
+            customPrimaryToolbarComponents: props.primaryToolbarComponents,
+            customSecondaryToolbarComponents: props.secondaryToolbarComponents,
+            contextPanel: props.contextPanel,
+            collabEdit: props.collabEdit,
+            persistScrollGutter: props.persistScrollGutter,
+            enableToolbarMinWidth: ((_props$featureFlags = props.featureFlags) === null || _props$featureFlags === void 0 ? void 0 : _props$featureFlags.toolbarMinWidthOverflow) != null ? !!((_props$featureFlags2 = props.featureFlags) !== null && _props$featureFlags2 !== void 0 && _props$featureFlags2.toolbarMinWidthOverflow) : props.allowUndoRedoButtons,
+            useStickyToolbar: props.useStickyToolbar,
+            featureFlags: featureFlags
+          }));
+        }
+      }), jsx(PortalRenderer, {
+        portalProviderAPI: portalProviderAPI
+      }));
+    }
+  }))))));
+}

package/dist/esm/editor-next/editor-migration-component.js

@@ -0,0 +1,44 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _extends from "@babel/runtime/helpers/extends";
+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 React from 'react';
+import { createFeatureFlagsFromProps } from '../create-editor/feature-flags-from-props';
+import Editor from '../editor';
+import EditorNext from './index';
+import useUniversalPreset from '../labs/next/presets/useUniversalPreset';
+var EditorNextWrapper = function EditorNextWrapper(_ref) {
+  var props = _ref.props;
+  var preset = useUniversalPreset({
+    props: props
+  });
+  return /*#__PURE__*/React.createElement(EditorNext, _extends({
+    preset: preset
+  }, props));
+};
+var EditorMigrationComponent = /*#__PURE__*/function (_React$Component) {
+  _inherits(EditorMigrationComponent, _React$Component);
+  var _super = _createSuper(EditorMigrationComponent);
+  function EditorMigrationComponent() {
+    _classCallCheck(this, EditorMigrationComponent);
+    return _super.apply(this, arguments);
+  }
+  _createClass(EditorMigrationComponent, [{
+    key: "render",
+    value: function render() {
+      var featureFlags = createFeatureFlagsFromProps(this.props);
+      if (!featureFlags.useEditorNext) {
+        return /*#__PURE__*/React.createElement(Editor, this.props);
+      }
+      return /*#__PURE__*/React.createElement(EditorNextWrapper, {
+        props: this.props
+      });
+    }
+  }]);
+  return EditorMigrationComponent;
+}(React.Component);
+export { EditorMigrationComponent as default };

package/dist/esm/editor-next/hooks/useEditorMeasuresConstructor.js

@@ -0,0 +1,30 @@
+/** @jsx jsx */
+
+import { useConstructor } from '@atlaskit/editor-common/hooks';
+import { measureTTI, startMeasure } from '@atlaskit/editor-common/utils';
+import measurements from '../../utils/performance/measure-enum';
+import editorMeasureTTICallback from '../utils/editorMeasureTTICallback';
+
+/**
+ *
+ * Hook to be used for running analytics on mounting the editor.
+ * Should run once.
+ * WARNING: Consider any changes to also make to `src/editor.tsx`
+ *
+ * @param performanceTracking
+ * @param featureFlags
+ * @param getExperienceStore function to retrieve the Editor's current ExperienceStore
+ * @param createAnalyticsEvent
+ */
+export default function useEditorConstructor(performanceTracking, featureFlags, getExperienceStore, createAnalyticsEvent) {
+  useConstructor(function () {
+    var _performanceTracking$;
+    startMeasure(measurements.EDITOR_MOUNTED);
+    if (performanceTracking !== null && performanceTracking !== void 0 && (_performanceTracking$ = performanceTracking.ttiTracking) !== null && _performanceTracking$ !== void 0 && _performanceTracking$.enabled || featureFlags !== null && featureFlags !== void 0 && featureFlags.ufo) {
+      var _performanceTracking$2, _performanceTracking$3;
+      measureTTI(function (tti, ttiFromInvocation, canceled) {
+        editorMeasureTTICallback(tti, ttiFromInvocation, canceled, performanceTracking, featureFlags, createAnalyticsEvent, getExperienceStore());
+      }, performanceTracking === null || performanceTracking === void 0 ? void 0 : (_performanceTracking$2 = performanceTracking.ttiTracking) === null || _performanceTracking$2 === void 0 ? void 0 : _performanceTracking$2.ttiIdleThreshold, performanceTracking === null || performanceTracking === void 0 ? void 0 : (_performanceTracking$3 = performanceTracking.ttiTracking) === null || _performanceTracking$3 === void 0 ? void 0 : _performanceTracking$3.ttiCancelTimeout);
+    }
+  });
+}

package/dist/esm/editor-next/hooks/useMeasureEditorMountTime.js

@@ -0,0 +1,35 @@
+/** @jsx jsx */
+import { useEffect } from 'react';
+import { clearMeasure, stopMeasure } from '@atlaskit/editor-common/utils';
+import { ACTION } from '@atlaskit/editor-common/analytics';
+import measurements from '../../utils/performance/measure-enum';
+import sendDurationAnalytics from '../utils/sendDurationAnalytics';
+import useEditorConstructor from './useEditorMeasuresConstructor';
+
+/**
+ *
+ * Hook to run the analytics for the Editor component.
+ * WARNING: Consider any changes to also make to `src/editor.tsx`
+ *
+ * @param props EditorProps
+ * @param getExperienceStore function to retrieve the Editor's current ExperienceStore
+ * @param createAnalyticsEvent
+ */
+export default function useMeasureEditorMountTime(props, getExperienceStore, createAnalyticsEvent) {
+  useEditorConstructor(props.performanceTracking, props.featureFlags, getExperienceStore, createAnalyticsEvent);
+  useEffect(function () {
+    stopMeasure(measurements.EDITOR_MOUNTED, sendDurationAnalytics(ACTION.EDITOR_MOUNTED, props, getExperienceStore, createAnalyticsEvent));
+    return function () {
+      var _props$performanceTra, _props$performanceTra2, _props$featureFlags;
+      clearMeasure(measurements.EDITOR_MOUNTED);
+      (props === null || props === void 0 ? void 0 : (_props$performanceTra = props.performanceTracking) === null || _props$performanceTra === void 0 ? void 0 : (_props$performanceTra2 = _props$performanceTra.onEditorReadyCallbackTracking) === null || _props$performanceTra2 === void 0 ? void 0 : _props$performanceTra2.enabled) && clearMeasure(measurements.ON_EDITOR_READY_CALLBACK);
+      if ((_props$featureFlags = props.featureFlags) !== null && _props$featureFlags !== void 0 && _props$featureFlags.ufo) {
+        var _getExperienceStore;
+        (_getExperienceStore = getExperienceStore()) === null || _getExperienceStore === void 0 ? void 0 : _getExperienceStore.abortAll({
+          reason: 'editor component unmounted'
+        });
+      }
+    };
+  }, []); // eslint-disable-line react-hooks/exhaustive-deps
+  // Disable Exhaustive Deps here since we only want to stop the measure on mount.
+}

package/dist/esm/editor-next/hooks/useProviderFactory.js

@@ -0,0 +1,66 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { useEffect, useRef, useState } from 'react';
+import { usePreviousState } from '@atlaskit/editor-common/hooks';
+import prepareQuickInsertProvider from '../../utils/prepare-quick-insert-provider';
+import prepareExtensionProvider from '../../utils/prepare-extension-provider';
+import handleProviders from '../utils/handleProviders';
+import getProvidersFromEditorProps from '../utils/getProvidersFromEditorProps';
+function createNewState(editorActions, quickInsert, extensionProviders, createAnalyticsEvent) {
+  var extensionProvider = prepareExtensionProvider(function () {
+    return editorActions;
+  })(extensionProviders);
+  var quickInsertProvider = prepareQuickInsertProvider(editorActions, extensionProvider, quickInsert, createAnalyticsEvent);
+  return {
+    extensionProvider: extensionProvider,
+    quickInsertProvider: quickInsertProvider
+  };
+}
+
+/**
+ *
+ * This hook is used to create the provider factory object.
+ * WARNING: Consider any changes to also make to `src/editor.tsx`
+ *
+ * @param props
+ * @param editorActions
+ * @param createAnalyticsEvent
+ * @returns ProviderFactory for Editor
+ */
+export default function useProviderFactory(props, editorActions, createAnalyticsEvent) {
+  var extensionProviders = props.extensionProviders,
+    quickInsert = props.quickInsert;
+  var providerFactory = useRef(new ProviderFactory());
+  var _useState = useState(createNewState(editorActions, quickInsert, extensionProviders, createAnalyticsEvent)),
+    _useState2 = _slicedToArray(_useState, 2),
+    providerState = _useState2[0],
+    setProviderState = _useState2[1];
+  var prevProps = usePreviousState({
+    extensionProviders: extensionProviders,
+    quickInsert: quickInsert
+  });
+  useEffect(function () {
+    if (extensionProviders && extensionProviders !== (prevProps === null || prevProps === void 0 ? void 0 : prevProps.extensionProviders) ||
+    // Though this will introduce some performance regression related to quick insert
+    // loading but we can remove it soon when Forge will move to new API.
+    // quickInsert={Promise.resolve(consumerQuickInsert)} is one of the main reason behind this performance issue.
+    quickInsert && quickInsert !== (prevProps === null || prevProps === void 0 ? void 0 : prevProps.quickInsert)) {
+      var newState = createNewState(editorActions, quickInsert, extensionProviders, createAnalyticsEvent);
+      setProviderState(newState);
+      handleProviders(providerFactory.current, getProvidersFromEditorProps(props), newState.extensionProvider, newState.quickInsertProvider);
+      return;
+    }
+    handleProviders(providerFactory.current, getProvidersFromEditorProps(props), providerState.extensionProvider, providerState.quickInsertProvider);
+  }, [props, prevProps === null || prevProps === void 0 ? void 0 : prevProps.quickInsert, prevProps === null || prevProps === void 0 ? void 0 : prevProps.extensionProviders, createAnalyticsEvent, editorActions, providerState.extensionProvider, providerState.quickInsertProvider, extensionProviders, quickInsert]);
+
+  // componentWillUnmount equivalent
+  useEffect(function () {
+    return function () {
+      // Disable this next line because it is not a React node
+      // so we can safely call destroy on the ref.
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      providerFactory.current.destroy();
+    };
+  }, []);
+  return providerFactory.current;
+}

package/dist/esm/editor-next/index.js

@@ -0,0 +1,138 @@
+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";
+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; }
+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 { WithCreateAnalyticsEvent } from '@atlaskit/editor-common/ui';
+import { getAnalyticsAppearance } from '@atlaskit/editor-common/utils';
+import { jsx } from '@emotion/react';
+import PropTypes from 'prop-types';
+import React from 'react';
+import { name, version } from '../version-wrapper';
+import { FabricEditorAnalyticsContext } from '@atlaskit/analytics-namespaced-context';
+import uuid from 'uuid/v4';
+import EditorActions from '../actions';
+import { fireAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import EditorInternal from './editor-internal';
+import { defaultProps, propTypes } from './utils/editorPropTypes';
+import trackEditorActions from './utils/trackEditorActions';
+import _onEditorCreated from './utils/onEditorCreated';
+import deprecationWarnings from './utils/deprecationWarnings';
+import { basePlugin } from '../plugins';
+var EditorNext = /*#__PURE__*/function (_React$Component) {
+  _inherits(EditorNext, _React$Component);
+  var _super = _createSuper(EditorNext);
+  /**
+   * WARNING: Code should be shared between Editor + EditorNext
+   * If you are making changes that affect both, consider making them
+   * in editor-next/editor-internal.tsx or editor-next/editor-utils.ts
+   */
+
+  function EditorNext(props, context) {
+    var _this;
+    _classCallCheck(this, EditorNext);
+    _this = _super.call(this, props);
+    _defineProperty(_assertThisInitialized(_this), "handleSave", function (view) {
+      var _this$props$onSave, _this$props;
+      return (_this$props$onSave = (_this$props = _this.props).onSave) === null || _this$props$onSave === void 0 ? void 0 : _this$props$onSave.call(_this$props, view);
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleAnalyticsEvent", function (data) {
+      return fireAnalyticsEvent(_this.createAnalyticsEvent)(data);
+    });
+    _defineProperty(_assertThisInitialized(_this), "getExperienceStore", function () {
+      return _this.experienceStore;
+    });
+    deprecationWarnings(props);
+    _this.editorActions = (context || {}).editorActions || new EditorActions();
+    _this.editorSessionId = uuid();
+    _this.startTime = performance.now();
+    _this.onEditorCreated = _this.onEditorCreated.bind(_assertThisInitialized(_this));
+    _this.onEditorDestroyed = _this.onEditorDestroyed.bind(_assertThisInitialized(_this));
+    _this.getExperienceStore = _this.getExperienceStore.bind(_assertThisInitialized(_this));
+    trackEditorActions(_this.editorActions, props.performanceTracking, function (value) {
+      return _this.handleAnalyticsEvent(value);
+    });
+    return _this;
+  }
+  _createClass(EditorNext, [{
+    key: "onEditorCreated",
+    value: function onEditorCreated(instance) {
+      var _this2 = this;
+      _onEditorCreated(instance, this.props, function (experienceStore) {
+        return _this2.experienceStore = experienceStore;
+      }, this.getExperienceStore, function () {
+        return _this2.createAnalyticsEvent;
+      }, this.editorActions, this.startTime, function (view, dispatcher, transformerForActions) {
+        return _this2.registerEditorForActions(view, dispatcher, transformerForActions);
+      });
+    }
+  }, {
+    key: "onEditorDestroyed",
+    value: function onEditorDestroyed(_instance) {
+      var _this$props$onDestroy, _this$props2;
+      this.unregisterEditorFromActions();
+      (_this$props$onDestroy = (_this$props2 = this.props).onDestroy) === null || _this$props$onDestroy === void 0 ? void 0 : _this$props$onDestroy.call(_this$props2);
+    }
+  }, {
+    key: "registerEditorForActions",
+    value: function registerEditorForActions(editorView, eventDispatcher, contentTransformer) {
+      this.editorActions._privateRegisterEditor(editorView, eventDispatcher, contentTransformer);
+    }
+  }, {
+    key: "unregisterEditorFromActions",
+    value: function unregisterEditorFromActions() {
+      this.editorActions._privateUnregisterEditor();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this3 = this;
+      return jsx(FabricEditorAnalyticsContext, {
+        data: {
+          packageName: name,
+          packageVersion: version,
+          componentName: 'editorCore',
+          appearance: getAnalyticsAppearance(this.props.appearance),
+          editorSessionId: this.editorSessionId
+        }
+      }, jsx(WithCreateAnalyticsEvent, {
+        render: function render(createAnalyticsEvent) {
+          return (_this3.createAnalyticsEvent = createAnalyticsEvent) && jsx(EditorInternal, {
+            props: _this3.props,
+            handleAnalyticsEvent: _this3.handleAnalyticsEvent,
+            createAnalyticsEvent: _this3.createAnalyticsEvent,
+            preset: _this3.props.preset,
+            handleSave: _this3.handleSave,
+            editorActions: _this3.editorActions,
+            getExperienceStore: _this3.getExperienceStore,
+            onEditorCreated: _this3.onEditorCreated,
+            onEditorDestroyed: _this3.onEditorDestroyed
+          });
+        }
+      }));
+    }
+  }]);
+  return EditorNext;
+}(React.Component);
+_defineProperty(EditorNext, "defaultProps", defaultProps);
+_defineProperty(EditorNext, "contextTypes", {
+  editorActions: PropTypes.object
+});
+_defineProperty(EditorNext, "propTypes", _objectSpread(_objectSpread({}, propTypes('minHeight only supports editor appearance chromeless and comment for EditorNext')), {}, {
+  preset: function preset(_ref) {
+    var _preset = _ref.preset;
+    if (!_preset.has(basePlugin)) {
+      return new Error('Presets must contain the base plugin');
+    }
+    return null;
+  }
+}));
+export { EditorNext as default };

package/dist/esm/editor-next/utils/deprecationWarnings.js

@@ -0,0 +1,39 @@
+import { nextMajorVersion } from '../../version-wrapper';
+export default function deprecationWarnings(props) {
+  var _props$allowTextColor;
+  if (process.env.NODE_ENV === 'production') {
+    return;
+  }
+  var nextVersion = nextMajorVersion();
+  var deprecatedProperties = {
+    allowTasksAndDecisions: {
+      message: 'To allow tasks and decisions use taskDecisionProvider – <Editor taskDecisionProvider={{ provider }} />',
+      type: 'removed'
+    },
+    allowConfluenceInlineComment: {
+      message: 'To integrate inline comments use experimental annotationProvider – <Editor annotationProviders={{ provider }} />',
+      type: 'removed'
+    },
+    smartLinks: {
+      message: 'To use smartLinks, pass the same object into the smartlinks key of linking - <Editor linking={{ smartLinks: {existing object} }}.',
+      type: 'removed'
+    }
+  };
+  Object.keys(deprecatedProperties).forEach(function (property) {
+    if (props.hasOwnProperty(property)) {
+      var meta = deprecatedProperties[property];
+      var type = meta.type || 'enabled by default';
+
+      // eslint-disable-next-line no-console
+      console.warn("".concat(property, " property is deprecated. ").concat(meta.message || '', " [Will be ").concat(type, " in editor-core@").concat(nextVersion, "]"));
+    }
+  });
+  if (props.hasOwnProperty('allowTables') && typeof props.allowTables !== 'boolean' && (!props.allowTables || !props.allowTables.advanced)) {
+    // eslint-disable-next-line no-console
+    console.warn("Advanced table options are deprecated (except isHeaderRowRequired) to continue using advanced table features use - <Editor allowTables={{ advanced: true }} /> [Will be changed in editor-core@".concat(nextVersion, "]"));
+  }
+  if (props.hasOwnProperty('allowTextColor') && typeof props.allowTextColor !== 'boolean' && (props === null || props === void 0 ? void 0 : (_props$allowTextColor = props.allowTextColor) === null || _props$allowTextColor === void 0 ? void 0 : _props$allowTextColor.allowMoreTextColors) !== undefined) {
+    // eslint-disable-next-line no-console
+    console.warn("\"allowMoreTextColors\" field of \"allowTextColor\" property is deprecated. It will be removedin editor-core@".concat(nextVersion, ". The color palette now shows more colors by default."));
+  }
+}

package/dist/esm/editor-next/utils/editorMeasureTTICallback.js

@@ -0,0 +1,38 @@
+import { getTTISeverity } from '@atlaskit/editor-common/utils';
+import { EditorExperience } from '@atlaskit/editor-common/ufo';
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE, fireAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+export default function editorMeasureTTICallback(tti, ttiFromInvocation, canceled, performanceTracking, featureFlags, createAnalyticsEvent, experienceStore) {
+  var _performanceTracking$;
+  if (performanceTracking !== null && performanceTracking !== void 0 && (_performanceTracking$ = performanceTracking.ttiTracking) !== null && _performanceTracking$ !== void 0 && _performanceTracking$.enabled && createAnalyticsEvent) {
+    var _ttiTracking;
+    var ttiEvent = {
+      payload: {
+        action: ACTION.EDITOR_TTI,
+        actionSubject: ACTION_SUBJECT.EDITOR,
+        attributes: {
+          tti: tti,
+          ttiFromInvocation: ttiFromInvocation,
+          canceled: canceled
+        },
+        eventType: EVENT_TYPE.OPERATIONAL
+      }
+    };
+    if ((_ttiTracking = performanceTracking.ttiTracking) !== null && _ttiTracking !== void 0 && _ttiTracking.trackSeverity) {
+      var _ttiTracking2 = performanceTracking.ttiTracking,
+        ttiSeverityNormalThreshold = _ttiTracking2.ttiSeverityNormalThreshold,
+        ttiSeverityDegradedThreshold = _ttiTracking2.ttiSeverityDegradedThreshold,
+        ttiFromInvocationSeverityNormalThreshold = _ttiTracking2.ttiFromInvocationSeverityNormalThreshold,
+        ttiFromInvocationSeverityDegradedThreshold = _ttiTracking2.ttiFromInvocationSeverityDegradedThreshold;
+      var _getTTISeverity = getTTISeverity(tti, ttiFromInvocation, ttiSeverityNormalThreshold, ttiSeverityDegradedThreshold, ttiFromInvocationSeverityNormalThreshold, ttiFromInvocationSeverityDegradedThreshold),
+        ttiSeverity = _getTTISeverity.ttiSeverity,
+        ttiFromInvocationSeverity = _getTTISeverity.ttiFromInvocationSeverity;
+      ttiEvent.payload.attributes.ttiSeverity = ttiSeverity;
+      ttiEvent.payload.attributes.ttiFromInvocationSeverity = ttiFromInvocationSeverity;
+    }
+    fireAnalyticsEvent(createAnalyticsEvent)(ttiEvent);
+  }
+  if (featureFlags !== null && featureFlags !== void 0 && featureFlags.ufo) {
+    experienceStore === null || experienceStore === void 0 ? void 0 : experienceStore.mark(EditorExperience.loadEditor, ACTION.EDITOR_TTI, tti);
+    experienceStore === null || experienceStore === void 0 ? void 0 : experienceStore.success(EditorExperience.loadEditor);
+  }
+}