@atlaskit/editor-core 180.0.0 → 180.1.0

package/dist/es2019/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/es2019/create-editor/create-plugins-list.js

@@ -80,6 +80,7 @@ export function getDefaultPresetOptionsFromEditorProps(props, createAnalyticsEve
     },
     cardOptions,
     hyperlinkOptions: {
+      editorAppearance: props.appearance,
       linkPicker: (_props$linking2 = props.linking) === null || _props$linking2 === void 0 ? void 0 : _props$linking2.linkPicker,
       cardOptions,
       platform: isMobile ? 'mobile' : 'web'

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

@@ -21,7 +21,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;
   const normalizedFeatureFlags = normalizeFeatureFlags(props.featureFlags);
   const tableCellOptionsInFloatingToolbar = normalizedFeatureFlags.tableCellOptionsInFloatingToolbar || ((_props$featureFlags = props.featureFlags) === null || _props$featureFlags === void 0 ? void 0 : _props$featureFlags.tableCellOptionsInFloatingToolbar) || undefined;
   return {
@@ -65,6 +65,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/es2019/editor-next/editor-internal.js

@@ -0,0 +1,142 @@
+/** @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) {
+  const {
+    props: editorProps,
+    getExperienceStore,
+    editorActions,
+    createAnalyticsEvent
+  } = props;
+  useMeasureEditorMountTime(editorProps, getExperienceStore, createAnalyticsEvent);
+  const providerFactory = useProviderFactory(editorProps, editorActions, createAnalyticsEvent);
+  const updatedProps = {
+    ...props,
+    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({
+  props,
+  handleAnalyticsEvent,
+  createAnalyticsEvent,
+  handleSave,
+  editorActions,
+  providerFactory,
+  onEditorCreated,
+  onEditorDestroyed,
+  getEditorPlugins
+}) {
+  var _props$performanceTra, _props$performanceTra2;
+  const Component = getUiComponent(props.appearance);
+  const overriddenEditorProps = {
+    ...props,
+    onSave: props.onSave ? handleSave : undefined,
+    // noop all analytic events, even if a handler is still passed.
+    analyticsHandler: undefined
+  };
+  const featureFlags = createFeatureFlagsFromProps(props);
+  const 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;
+  const renderTrackingEnabled = renderTracking === null || renderTracking === void 0 ? void 0 : renderTracking.enabled;
+  const 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: portalProviderAPI => jsx(Fragment, null, jsx(ReactEditorView, {
+      editorProps: overriddenEditorProps,
+      createAnalyticsEvent: createAnalyticsEvent,
+      portalProviderAPI: portalProviderAPI,
+      providerFactory: providerFactory,
+      onEditorCreated: onEditorCreated,
+      onEditorDestroyed: onEditorDestroyed,
+      allowAnalyticsGASV3: props.allowAnalyticsGASV3,
+      disabled: props.disabled,
+      getEditorPlugins: getEditorPlugins,
+      render: ({
+        editor,
+        view,
+        eventDispatcher,
+        config,
+        dispatchAnalyticsEvent,
+        editorRef
+      }) => {
+        var _props$featureFlags, _props$featureFlags2;
+        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/es2019/editor-next/editor-migration-component.js

@@ -0,0 +1,10 @@
+import React from 'react';
+import Editor from '../editor';
+import EditorNext from './index';
+import { createFeatureFlagsFromProps } from '../create-editor/feature-flags-from-props';
+export default class EditorMigrationComponent extends React.Component {
+  render() {
+    const featureFlags = createFeatureFlagsFromProps(this.props);
+    return featureFlags.useEditorNext ? /*#__PURE__*/React.createElement(EditorNext, this.props) : /*#__PURE__*/React.createElement(Editor, this.props);
+  }
+}

package/dist/es2019/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(() => {
+    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((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/es2019/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(() => {
+    stopMeasure(measurements.EDITOR_MOUNTED, sendDurationAnalytics(ACTION.EDITOR_MOUNTED, props, getExperienceStore, createAnalyticsEvent));
+    return () => {
+      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/es2019/editor-next/hooks/useProviderFactory.js

@@ -0,0 +1,61 @@
+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';
+function createNewState(editorActions, quickInsert, extensionProviders, createAnalyticsEvent) {
+  const extensionProvider = prepareExtensionProvider(() => editorActions)(extensionProviders);
+  const quickInsertProvider = prepareQuickInsertProvider(editorActions, extensionProvider, quickInsert, createAnalyticsEvent);
+  return {
+    extensionProvider,
+    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) {
+  const {
+    extensionProviders,
+    quickInsert
+  } = props;
+  const providerFactory = useRef(new ProviderFactory());
+  const [providerState, setProviderState] = useState(createNewState(editorActions, quickInsert, extensionProviders, createAnalyticsEvent));
+  const prevProps = usePreviousState({
+    extensionProviders,
+    quickInsert
+  });
+  useEffect(() => {
+    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)) {
+      const newState = createNewState(editorActions, quickInsert, extensionProviders, createAnalyticsEvent);
+      setProviderState(newState);
+      handleProviders(providerFactory.current, props, newState.extensionProvider, newState.quickInsertProvider);
+      return;
+    }
+    handleProviders(providerFactory.current, props, providerState.extensionProvider, providerState.quickInsertProvider);
+  }, [props, prevProps, createAnalyticsEvent, editorActions, providerState.extensionProvider, providerState.quickInsertProvider, extensionProviders, quickInsert]);
+
+  // componentWillUnmount equivalent
+  useEffect(() => {
+    return () => {
+      // 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/es2019/editor-next/index.js

@@ -0,0 +1,90 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/** @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 getEditorPlugins from '../utils/get-editor-plugins';
+export default class EditorNext extends React.Component {
+  /**
+   * 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
+   */
+
+  constructor(props, context) {
+    super(props);
+    _defineProperty(this, "handleSave", 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(this, "handleAnalyticsEvent", data => fireAnalyticsEvent(this.createAnalyticsEvent)(data));
+    _defineProperty(this, "getExperienceStore", () => this.experienceStore);
+    deprecationWarnings(props);
+    this.editorActions = (context || {}).editorActions || new EditorActions();
+    this.editorSessionId = uuid();
+    this.startTime = performance.now();
+    this.onEditorCreated = this.onEditorCreated.bind(this);
+    this.onEditorDestroyed = this.onEditorDestroyed.bind(this);
+    this.getExperienceStore = this.getExperienceStore.bind(this);
+    this.getEditorPlugins = this.getEditorPlugins.bind(this);
+    trackEditorActions(this.editorActions, props.performanceTracking, value => this.handleAnalyticsEvent(value));
+  }
+  onEditorCreated(instance) {
+    onEditorCreated(instance, this.props, experienceStore => this.experienceStore = experienceStore, this.getExperienceStore, () => this.createAnalyticsEvent, this.editorActions, this.startTime, (view, dispatcher, transformerForActions) => this.registerEditorForActions(view, dispatcher, transformerForActions));
+  }
+  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);
+  }
+  registerEditorForActions(editorView, eventDispatcher, contentTransformer) {
+    this.editorActions._privateRegisterEditor(editorView, eventDispatcher, contentTransformer);
+  }
+  unregisterEditorFromActions() {
+    this.editorActions._privateUnregisterEditor();
+  }
+  render() {
+    return jsx(FabricEditorAnalyticsContext, {
+      data: {
+        packageName: name,
+        packageVersion: version,
+        componentName: 'editorCore',
+        appearance: getAnalyticsAppearance(this.props.appearance),
+        editorSessionId: this.editorSessionId
+      }
+    }, jsx(WithCreateAnalyticsEvent, {
+      render: createAnalyticsEvent => (this.createAnalyticsEvent = createAnalyticsEvent) && jsx(EditorInternal, {
+        props: this.props,
+        handleAnalyticsEvent: this.handleAnalyticsEvent,
+        createAnalyticsEvent: this.createAnalyticsEvent,
+        getEditorPlugins: this.getEditorPlugins,
+        handleSave: this.handleSave,
+        editorActions: this.editorActions,
+        getExperienceStore: this.getExperienceStore,
+        onEditorCreated: this.onEditorCreated,
+        onEditorDestroyed: this.onEditorDestroyed
+      })
+    }));
+  }
+  getEditorPlugins(props) {
+    return getEditorPlugins(props);
+  }
+}
+_defineProperty(EditorNext, "defaultProps", defaultProps);
+_defineProperty(EditorNext, "contextTypes", {
+  editorActions: PropTypes.object
+});
+_defineProperty(EditorNext, "propTypes", propTypes('minHeight only supports editor appearance chromeless and comment for EditorNext'));

package/dist/es2019/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;
+  }
+  const nextVersion = nextMajorVersion();
+  const 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(property => {
+    if (props.hasOwnProperty(property)) {
+      const meta = deprecatedProperties[property];
+      const type = meta.type || 'enabled by default';
+
+      // eslint-disable-next-line no-console
+      console.warn(`${property} property is deprecated. ${meta.message || ''} [Will be ${type} in editor-core@${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@${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@${nextVersion}. The color palette now shows more colors by default.`);
+  }
+}

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

@@ -0,0 +1,40 @@
+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;
+    const ttiEvent = {
+      payload: {
+        action: ACTION.EDITOR_TTI,
+        actionSubject: ACTION_SUBJECT.EDITOR,
+        attributes: {
+          tti,
+          ttiFromInvocation,
+          canceled
+        },
+        eventType: EVENT_TYPE.OPERATIONAL
+      }
+    };
+    if ((_ttiTracking = performanceTracking.ttiTracking) !== null && _ttiTracking !== void 0 && _ttiTracking.trackSeverity) {
+      const {
+        ttiSeverityNormalThreshold,
+        ttiSeverityDegradedThreshold,
+        ttiFromInvocationSeverityNormalThreshold,
+        ttiFromInvocationSeverityDegradedThreshold
+      } = performanceTracking.ttiTracking;
+      const {
+        ttiSeverity,
+        ttiFromInvocationSeverity
+      } = getTTISeverity(tti, ttiFromInvocation, ttiSeverityNormalThreshold, ttiSeverityDegradedThreshold, ttiFromInvocationSeverityNormalThreshold, ttiFromInvocationSeverityDegradedThreshold);
+      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);
+  }
+}

package/dist/es2019/editor-next/utils/editorPropTypes.js

@@ -0,0 +1,29 @@
+/**
+ *
+ * Logic for Editor prop types (ie. `static propTypes = propTypes(message)`)
+ * for use with 'prop-types' library
+ *
+ * @param errorMessage
+ * @returns Editor prop-types
+ */
+export function propTypes(errorMessage) {
+  return {
+    minHeight: ({
+      appearance,
+      minHeight
+    }) => {
+      if (minHeight && appearance && !['comment', 'chromeless'].includes(appearance)) {
+        return new Error(errorMessage);
+      }
+      return null;
+    }
+  };
+}
+export const defaultProps = {
+  appearance: 'comment',
+  disabled: false,
+  extensionHandlers: {},
+  allowHelpDialog: true,
+  allowNewInsertionBehaviour: true,
+  quickInsert: true
+};

package/dist/es2019/editor-next/utils/getBaseFontSize.js

@@ -0,0 +1,11 @@
+import { akEditorFullPageDefaultFontSize } from '@atlaskit/editor-shared-styles';
+/**
+ * @param appearance
+ * @returns default font size if valid
+ */
+export function getBaseFontSize(appearance) {
+  if (appearance === undefined) {
+    return akEditorFullPageDefaultFontSize;
+  }
+  return !['comment', 'chromeless', 'mobile'].includes(appearance) ? akEditorFullPageDefaultFontSize : undefined;
+}

package/dist/es2019/editor-next/utils/handleProviders.js

@@ -0,0 +1,52 @@
+/**
+ *
+ * Utility to set all the providers on a provider factory
+ *
+ * @param providerFactory
+ * @param props
+ * @param extensionProvider
+ * @param quickInsertProvider
+ */
+export default function handleProviders(providerFactory, props, extensionProvider, quickInsertProvider) {
+  var _linking$smartLinks;
+  const {
+    emojiProvider,
+    mentionProvider,
+    taskDecisionProvider,
+    contextIdentifierProvider,
+    collabEditProvider,
+    activityProvider,
+    presenceProvider,
+    macroProvider,
+    legacyImageUploadProvider,
+    media,
+    collabEdit,
+    autoformattingProvider,
+    searchProvider,
+    UNSAFE_cards,
+    smartLinks,
+    linking
+  } = props;
+  providerFactory.setProvider('emojiProvider', emojiProvider);
+  providerFactory.setProvider('mentionProvider', mentionProvider);
+  providerFactory.setProvider('taskDecisionProvider', taskDecisionProvider);
+  providerFactory.setProvider('contextIdentifierProvider', contextIdentifierProvider);
+  providerFactory.setProvider('mediaProvider', media && media.provider);
+  providerFactory.setProvider('imageUploadProvider', legacyImageUploadProvider);
+  providerFactory.setProvider('collabEditProvider', collabEdit && collabEdit.provider ? collabEdit.provider : collabEditProvider);
+  providerFactory.setProvider('activityProvider', activityProvider);
+  providerFactory.setProvider('searchProvider', searchProvider);
+  providerFactory.setProvider('presenceProvider', presenceProvider);
+  providerFactory.setProvider('macroProvider', macroProvider);
+  const cardProvider = (linking === null || linking === void 0 ? void 0 : (_linking$smartLinks = linking.smartLinks) === null || _linking$smartLinks === void 0 ? void 0 : _linking$smartLinks.provider) || smartLinks && smartLinks.provider || UNSAFE_cards && UNSAFE_cards.provider;
+  if (cardProvider) {
+    providerFactory.setProvider('cardProvider', cardProvider);
+  }
+  providerFactory.setProvider('autoformattingProvider', autoformattingProvider);
+  if (extensionProvider) {
+    providerFactory.setProvider('extensionProvider', Promise.resolve(extensionProvider));
+  }
+  if (quickInsertProvider) {
+    providerFactory.setProvider('quickInsertProvider', quickInsertProvider);
+  }
+}

package/dist/es2019/editor-next/utils/onEditorCreated.js

@@ -0,0 +1,21 @@
+import { EditorExperience, ExperienceStore } from '@atlaskit/editor-common/ufo';
+import { startMeasure, stopMeasure } from '@atlaskit/editor-common/utils';
+import { ACTION } from '@atlaskit/editor-common/analytics';
+import measurements from '../../utils/performance/measure-enum';
+import sendDurationAnalytics from './sendDurationAnalytics';
+export default function onEditorCreated(instance, props, setExperienceStore, getExperienceStore, getCreateAnalyticsEvent, editorActions, startTime, registerEditorForActions) {
+  var _props$featureFlags;
+  registerEditorForActions(instance.view, instance.eventDispatcher, instance.transformer);
+  if ((_props$featureFlags = props.featureFlags) !== null && _props$featureFlags !== void 0 && _props$featureFlags.ufo) {
+    var _getExperienceStore;
+    setExperienceStore(ExperienceStore.getInstance(instance.view));
+    (_getExperienceStore = getExperienceStore()) === null || _getExperienceStore === void 0 ? void 0 : _getExperienceStore.start(EditorExperience.loadEditor, startTime);
+  }
+  if (props.onEditorReady) {
+    var _props$performanceTra, _props$performanceTra2, _props$featureFlags2;
+    const measureEditorReady = (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) || ((_props$featureFlags2 = props.featureFlags) === null || _props$featureFlags2 === void 0 ? void 0 : _props$featureFlags2.ufo);
+    measureEditorReady && startMeasure(measurements.ON_EDITOR_READY_CALLBACK);
+    props.onEditorReady(editorActions);
+    measureEditorReady && stopMeasure(measurements.ON_EDITOR_READY_CALLBACK, sendDurationAnalytics(ACTION.ON_EDITOR_READY_CALLBACK, props, getExperienceStore, getCreateAnalyticsEvent()));
+  }
+}