@atlaskit/editor-core 188.6.0 → 188.7.3

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @atlaskit/editor-core
 
+## 188.7.3
+
+### Patch Changes
+
+- [#41387](https://bitbucket.org/atlassian/atlassian-frontend/pull-requests/41387) [`5b2cd469875`](https://bitbucket.org/atlassian/atlassian-frontend/commits/5b2cd469875) - Fix scrolling to top of page on status selection.
+- Updated dependencies
+
+## 188.7.0
+
+### Minor Changes
+
+- [#41355](https://bitbucket.org/atlassian/atlassian-frontend/pull-requests/41355) [`150c2a815ac`](https://bitbucket.org/atlassian/atlassian-frontend/commits/150c2a815ac) - Editor now forcibly sets position static on its dropdown menu items.
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 188.6.0
 
 ### Minor Changes

package/dist/cjs/plugins/status/ui/statusPicker.js

@@ -224,17 +224,22 @@ var StatusPickerWithoutAnalytcs = exports.StatusPickerWithoutAnalytcs = /*#__PUR
   }, {
     key: "componentDidMount",
     value: function componentDidMount() {
+      var _this2 = this;
       this.reset();
       this.fireStatusPopupOpenedAnalytics(this.state);
       if (typeof this.props.isNew === 'boolean' && this.props.isNew === false) {
-        var _this$popupBodyWrappe2;
         // Wrapper should be focused only if status already exists otherwise input field will receive focus
-        (_this$popupBodyWrappe2 = this.popupBodyWrapper) === null || _this$popupBodyWrappe2 === void 0 || (_this$popupBodyWrappe2 = _this$popupBodyWrappe2.current) === null || _this$popupBodyWrappe2 === void 0 || _this$popupBodyWrappe2.focus();
+        this.focusTimeout = requestAnimationFrame(function () {
+          var _this2$popupBodyWrapp;
+          // Defer to prevent editor scrolling to top. See https://product-fabric.atlassian.net/browse/DTR-1952
+          (_this2$popupBodyWrapp = _this2.popupBodyWrapper) === null || _this2$popupBodyWrapp === void 0 || (_this2$popupBodyWrapp = _this2$popupBodyWrapp.current) === null || _this2$popupBodyWrapp === void 0 || _this2$popupBodyWrapp.focus();
+        });
       }
     }
   }, {
     key: "componentWillUnmount",
     value: function componentWillUnmount() {
+      this.focusTimeout && cancelAnimationFrame(this.focusTimeout);
       this.fireStatusPopupClosedAnalytics(this.state);
       this.startTime = 0;
     }

package/dist/cjs/version-wrapper.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.version = exports.nextMajorVersion = exports.name = void 0;
 var name = exports.name = "@atlaskit/editor-core";
-var version = exports.version = "188.6.0";
+var version = exports.version = "0.0.0-development";
 var nextMajorVersion = exports.nextMajorVersion = function nextMajorVersion() {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/es2019/plugins/status/ui/statusPicker.js

@@ -213,12 +213,16 @@ export class StatusPickerWithoutAnalytcs extends React.Component {
     this.reset();
     this.fireStatusPopupOpenedAnalytics(this.state);
     if (typeof this.props.isNew === 'boolean' && this.props.isNew === false) {
-      var _this$popupBodyWrappe3, _this$popupBodyWrappe4;
       // Wrapper should be focused only if status already exists otherwise input field will receive focus
-      (_this$popupBodyWrappe3 = this.popupBodyWrapper) === null || _this$popupBodyWrappe3 === void 0 ? void 0 : (_this$popupBodyWrappe4 = _this$popupBodyWrappe3.current) === null || _this$popupBodyWrappe4 === void 0 ? void 0 : _this$popupBodyWrappe4.focus();
+      this.focusTimeout = requestAnimationFrame(() => {
+        var _this$popupBodyWrappe3, _this$popupBodyWrappe4;
+        // Defer to prevent editor scrolling to top. See https://product-fabric.atlassian.net/browse/DTR-1952
+        (_this$popupBodyWrappe3 = this.popupBodyWrapper) === null || _this$popupBodyWrappe3 === void 0 ? void 0 : (_this$popupBodyWrappe4 = _this$popupBodyWrappe3.current) === null || _this$popupBodyWrappe4 === void 0 ? void 0 : _this$popupBodyWrappe4.focus();
+      });
     }
   }
   componentWillUnmount() {
+    this.focusTimeout && cancelAnimationFrame(this.focusTimeout);
     this.fireStatusPopupClosedAnalytics(this.state);
     this.startTime = 0;
   }

package/dist/es2019/version-wrapper.js

@@ -1,5 +1,5 @@
 export const name = "@atlaskit/editor-core";
-export const version = "188.6.0";
+export const version = "0.0.0-development";
 export const nextMajorVersion = () => {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/esm/plugins/status/ui/statusPicker.js

@@ -218,17 +218,22 @@ export var StatusPickerWithoutAnalytcs = /*#__PURE__*/function (_React$Component
   }, {
     key: "componentDidMount",
     value: function componentDidMount() {
+      var _this2 = this;
       this.reset();
       this.fireStatusPopupOpenedAnalytics(this.state);
       if (typeof this.props.isNew === 'boolean' && this.props.isNew === false) {
-        var _this$popupBodyWrappe2;
         // Wrapper should be focused only if status already exists otherwise input field will receive focus
-        (_this$popupBodyWrappe2 = this.popupBodyWrapper) === null || _this$popupBodyWrappe2 === void 0 || (_this$popupBodyWrappe2 = _this$popupBodyWrappe2.current) === null || _this$popupBodyWrappe2 === void 0 || _this$popupBodyWrappe2.focus();
+        this.focusTimeout = requestAnimationFrame(function () {
+          var _this2$popupBodyWrapp;
+          // Defer to prevent editor scrolling to top. See https://product-fabric.atlassian.net/browse/DTR-1952
+          (_this2$popupBodyWrapp = _this2.popupBodyWrapper) === null || _this2$popupBodyWrapp === void 0 || (_this2$popupBodyWrapp = _this2$popupBodyWrapp.current) === null || _this2$popupBodyWrapp === void 0 || _this2$popupBodyWrapp.focus();
+        });
       }
     }
   }, {
     key: "componentWillUnmount",
     value: function componentWillUnmount() {
+      this.focusTimeout && cancelAnimationFrame(this.focusTimeout);
       this.fireStatusPopupClosedAnalytics(this.state);
       this.startTime = 0;
     }

package/dist/esm/version-wrapper.js

@@ -1,5 +1,5 @@
 export var name = "@atlaskit/editor-core";
-export var version = "188.6.0";
+export var version = "0.0.0-development";
 export var nextMajorVersion = function nextMajorVersion() {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/types/plugins/status/ui/statusPicker.d.ts

@@ -38,6 +38,7 @@ export declare class StatusPickerWithoutAnalytcs extends React.Component<Props,
     private inputMethod?;
     private createStatusAnalyticsAndFireFunc;
     private popupBodyWrapper;
+    private focusTimeout;
     constructor(props: Props);
     private fireStatusPopupOpenedAnalytics;
     private fireStatusPopupClosedAnalytics;

package/dist/types-ts4.5/actions/index.d.ts

@@ -0,0 +1,49 @@
+import { Node } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { AnalyticsEventPayload } from '@atlaskit/analytics-next/AnalyticsEvent';
+import type { ResolvedEditorState } from '@atlaskit/editor-common/collab';
+import type { ContextUpdateHandler, EditorActionsOptions, ReplaceRawValue, FeatureFlags, Transformer } from '@atlaskit/editor-common/types';
+import type { EventDispatcher } from '../event-dispatcher';
+export default class EditorActions<T = any> implements EditorActionsOptions<T> {
+    private editorView?;
+    private contentTransformer?;
+    private contentEncode?;
+    private eventDispatcher?;
+    private listeners;
+    static from<T>(view: EditorView, eventDispatcher: EventDispatcher, transformer?: Transformer<T>): EditorActions<T>;
+    _privateGetEditorView(): EditorView | undefined;
+    _privateGetEventDispatcher(): EventDispatcher | undefined;
+    private getFeatureFlags;
+    _privateRegisterEditor(editorView: EditorView, eventDispatcher: EventDispatcher, contentTransformer?: Transformer<T>, getFeatureFlags?: () => FeatureFlags): void;
+    _privateUnregisterEditor(): void;
+    _privateSubscribe(cb: ContextUpdateHandler): void;
+    _privateUnsubscribe(cb: ContextUpdateHandler): void;
+    focus(): boolean;
+    blur(): boolean;
+    clear(): boolean;
+    __temporaryFixForConfigPanel(): Promise<void>;
+    getValue(): Promise<T | import("@atlaskit/editor-json-transformer/types").JSONDocNode | undefined>;
+    getNodeByLocalId(id: string): Node | undefined;
+    getNodeByFragmentLocalId(id: string): Node | undefined;
+    /**
+     * This method will return the currently selected `Node` if the selection is a `Node`.
+     * Otherwise, if the selection is textual or a non-selectable `Node` within another selectable `Node`, the closest selectable parent `Node` will be returned.
+     */
+    getSelectedNode(): Node | undefined;
+    isDocumentEmpty(): boolean;
+    replaceDocument(rawValue: any, shouldScrollToBottom?: boolean, 
+    /** @deprecated [ED-14158] shouldAddToHistory is not being used in this function */
+    shouldAddToHistory?: boolean): boolean;
+    replaceSelection(rawValue: ReplaceRawValue | Array<ReplaceRawValue>, tryToReplace?: boolean): boolean;
+    appendText(text: string): boolean;
+    dispatchAnalyticsEvent: (payload: AnalyticsEventPayload) => void;
+    /**
+     * If editor is using new collab service,
+     * we want editor to call the collab provider to
+     * retrieve the final acknowledged state of the
+     * editor. The final acknowledged editor state
+     * refers to the latest state of editor with confirmed
+     * steps.
+     */
+    getResolvedEditorState: () => Promise<ResolvedEditorState | undefined>;
+}

package/dist/types-ts4.5/commands/index.d.ts

@@ -0,0 +1 @@
+export { addParagraphAtEnd, createParagraphAtEnd, changeImageAlignment, createToggleBlockMarkOnRange, toggleBlockMark, clearEditorContent, } from '@atlaskit/editor-common/commands';

package/dist/types-ts4.5/composable-editor/editor-internal.d.ts

@@ -0,0 +1,34 @@
+import { jsx } from '@emotion/react';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { FireAnalyticsCallback } from '@atlaskit/editor-common/analytics';
+import type { EditorPresetBuilder } from '@atlaskit/editor-common/preset';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { AllEditorPresetPluginTypes, Transformer } from '@atlaskit/editor-common/types';
+import type EditorActions from '../actions';
+import type { EventDispatcher } from '../event-dispatcher';
+import type { EditorNextProps } from '../types/editor-props';
+interface InternalProps {
+    props: EditorNextProps;
+    handleAnalyticsEvent: FireAnalyticsCallback;
+    createAnalyticsEvent: CreateUIAnalyticsEvent;
+    handleSave: (view: EditorView) => void;
+    editorActions: EditorActions;
+    onEditorCreated: (instance: {
+        view: EditorView;
+        eventDispatcher: EventDispatcher;
+        transformer?: Transformer<string>;
+    }) => void;
+    onEditorDestroyed: (_instance: {
+        view: EditorView;
+        transformer?: Transformer<string>;
+    }) => void;
+    preset: EditorPresetBuilder<string[], AllEditorPresetPluginTypes[]>;
+    providerFactory: ProviderFactory;
+}
+/**
+ * EditorInternalComponent is used to capture the common component
+ * from the `render` method of `Editor` and share it with `EditorNext`.
+ */
+export declare function EditorInternal({ props, handleAnalyticsEvent, createAnalyticsEvent, handleSave, editorActions, providerFactory, onEditorCreated, onEditorDestroyed, preset, }: InternalProps): jsx.JSX.Element;
+export {};

package/dist/types-ts4.5/composable-editor/editor.d.ts

@@ -0,0 +1,9 @@
+import { jsx } from '@emotion/react';
+import type { EditorNextProps } from '../types/editor-props';
+export declare function ComposableEditor(props: EditorNextProps): jsx.JSX.Element;
+export declare namespace ComposableEditor {
+    var propTypes: {
+        minHeight: ({ appearance, minHeight, }: Pick<EditorNextProps, "appearance" | "minHeight">) => Error | null;
+        preset: ({ preset }: Pick<EditorNextProps, "preset">) => Error | null;
+    };
+}

package/dist/types-ts4.5/composable-editor/hooks/useEditorMeasuresConstructor.d.ts

@@ -0,0 +1,17 @@
+/** @jsx jsx */
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { ExperienceStore } from '@atlaskit/editor-common/ufo';
+import type { EditorProps } from '../../types/editor-props';
+import type { PerformanceTracking } from '../../types/performance-tracking';
+/**
+ *
+ * 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: PerformanceTracking | undefined, featureFlags: EditorProps['featureFlags'], getExperienceStore: () => ExperienceStore | undefined, createAnalyticsEvent: CreateUIAnalyticsEvent): void;

package/dist/types-ts4.5/composable-editor/hooks/useMeasureEditorMountTime.d.ts

@@ -0,0 +1,13 @@
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { ExperienceStore } from '@atlaskit/editor-common/ufo';
+import type { EditorNextProps, EditorProps } from '../../types/editor-props';
+/**
+ *
+ * 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: EditorProps | EditorNextProps, getExperienceStore: () => ExperienceStore | undefined, createAnalyticsEvent: CreateUIAnalyticsEvent): void;

package/dist/types-ts4.5/composable-editor/hooks/useProviderFactory.d.ts

@@ -0,0 +1,14 @@
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type EditorActions from '../../actions';
+import type { EditorNextProps } from '../../types/editor-props';
+/**
+ *
+ * This hook is used to create the provider factory object.
+ *
+ * @param props
+ * @param editorActions
+ * @param createAnalyticsEvent
+ * @returns ProviderFactory for Editor
+ */
+export default function useProviderFactory(props: EditorNextProps, editorActions: EditorActions, createAnalyticsEvent: CreateUIAnalyticsEvent): ProviderFactory;

package/dist/types-ts4.5/composable-editor/utils/editorMeasureTTICallback.d.ts

@@ -0,0 +1,5 @@
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { ExperienceStore } from '@atlaskit/editor-common/ufo';
+import type { EditorProps } from '../../types/editor-props';
+import type { PerformanceTracking } from '../../types/performance-tracking';
+export default function editorMeasureTTICallback(tti: number, ttiFromInvocation: number, canceled: boolean, distortedDuration: boolean, performanceTracking: PerformanceTracking | undefined, featureFlags: EditorProps['featureFlags'], createAnalyticsEvent?: CreateUIAnalyticsEvent, experienceStore?: ExperienceStore): void;

package/dist/types-ts4.5/composable-editor/utils/getBaseFontSize.d.ts

@@ -0,0 +1,6 @@
+import type { EditorAppearance } from '@atlaskit/editor-common/types';
+/**
+ * @param appearance
+ * @returns default font size if valid
+ */
+export declare function getBaseFontSize(appearance?: EditorAppearance): number | undefined;

package/dist/types-ts4.5/composable-editor/utils/getProvidersFromEditorProps.d.ts

@@ -0,0 +1,9 @@
+import type { Providers } from '@atlaskit/editor-common/provider-factory';
+import type { EditorProps } from '../../types/editor-props';
+type Complete<T> = {
+    [P in keyof Required<T>]: Pick<T, P> extends Required<Pick<T, P>> ? T[P] : T[P] | undefined;
+};
+type EditorProviderProps = Pick<EditorProps, 'linking' | 'smartLinks' | 'UNSAFE_cards' | 'autoformattingProvider' | 'media' | 'emojiProvider' | 'mentionProvider' | 'taskDecisionProvider' | 'contextIdentifierProvider' | 'searchProvider' | 'macroProvider' | 'activityProvider' | 'collabEdit' | 'collabEditProvider' | 'presenceProvider' | 'legacyImageUploadProvider'>;
+type RequiredProviders = Complete<Omit<Providers, 'reactionsStore' | 'profilecardProvider' | 'extensionProvider' | 'quickInsertProvider'>>;
+export default function getProvidersFromEditorProps({ linking, smartLinks, UNSAFE_cards, autoformattingProvider, media, emojiProvider, mentionProvider, legacyImageUploadProvider, taskDecisionProvider, contextIdentifierProvider, searchProvider, macroProvider, activityProvider, collabEdit, collabEditProvider, presenceProvider, }: EditorProviderProps): RequiredProviders;
+export {};

package/dist/types-ts4.5/composable-editor/utils/handleProviders.d.ts

@@ -0,0 +1,12 @@
+import type { ExtensionProvider } from '@atlaskit/editor-common/extensions';
+import type { ProviderFactory, Providers, QuickInsertProvider } from '@atlaskit/editor-common/provider-factory';
+/**
+ *
+ * Utility to set all the providers on a provider factory
+ *
+ * @param providerFactory
+ * @param props
+ * @param extensionProvider
+ * @param quickInsertProvider
+ */
+export default function handleProviders(providerFactory: ProviderFactory, { emojiProvider, mentionProvider, taskDecisionProvider, contextIdentifierProvider, collabEditProvider, activityProvider, presenceProvider, macroProvider, imageUploadProvider, mediaProvider, autoformattingProvider, searchProvider, cardProvider, }: Providers, extensionProvider?: ExtensionProvider, quickInsertProvider?: Promise<QuickInsertProvider>): void;

package/dist/types-ts4.5/composable-editor/utils/sendDurationAnalytics.d.ts

@@ -0,0 +1,15 @@
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { ACTION } from '@atlaskit/editor-common/analytics';
+import type { ExperienceStore } from '@atlaskit/editor-common/ufo';
+import type { EditorProps } from '../../types/editor-props';
+/**
+ *
+ * Util function to be used with the Editor component to send duration analytics
+ *
+ * @param action
+ * @param props
+ * @param getExperienceStore return the ExperienceStore of the Editor
+ * @param getCreateAnalyticsEvent return the CreateUIAnalyticsEvent of the Editor
+ * @returns
+ */
+export default function sendDurationAnalytics(action: ACTION.EDITOR_MOUNTED | ACTION.ON_EDITOR_READY_CALLBACK, props: Pick<EditorProps, 'contextIdentifierProvider' | 'featureFlags'>, getExperienceStore: () => ExperienceStore | undefined, createAnalyticsEvent: CreateUIAnalyticsEvent | undefined): (duration: number, startTime: number) => Promise<void>;

package/dist/types-ts4.5/composable-editor/utils/trackEditorActions.d.ts

@@ -0,0 +1,29 @@
+import type { FireAnalyticsCallback } from '@atlaskit/editor-common/analytics';
+import type EditorActions from '../../actions';
+import type { PerformanceTracking } from '../../types/performance-tracking';
+/**
+ *
+ * Util function to be used with the Editor to track the EditorActions prop
+ *
+ * @param editorActions
+ * @param performanceTracking
+ * @param handleAnalyticsEvent
+ * @returns
+ */
+export default function trackEditorActions(editorActions: EditorActions & {
+    _contentRetrievalTracking?: {
+        getValueTracked: boolean;
+        samplingCounters: {
+            success: number;
+            failure: number;
+        };
+    };
+}, performanceTracking: PerformanceTracking | undefined, handleAnalyticsEvent: FireAnalyticsCallback): EditorActions<any> & {
+    _contentRetrievalTracking?: {
+        getValueTracked: boolean;
+        samplingCounters: {
+            success: number;
+            failure: number;
+        };
+    } | undefined;
+};

package/dist/types-ts4.5/composable-editor.d.ts

@@ -0,0 +1 @@
+export { ComposableEditor } from './composable-editor/editor';

package/dist/types-ts4.5/create-editor/ErrorBoundary.d.ts

@@ -0,0 +1,44 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import React from 'react';
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import { ExperienceStore } from '@atlaskit/editor-common/ufo';
+import type { UserBrowserExtensionResults } from '@atlaskit/editor-common/utils';
+import type { FeatureFlags } from '../types/feature-flags';
+export type ErrorBoundaryProps = {
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    editorView?: EditorView;
+    rethrow?: boolean;
+    children: React.ReactNode;
+    featureFlags: FeatureFlags;
+    errorTracking?: boolean;
+};
+export type ErrorBoundaryState = {
+    error?: Error;
+};
+type AnalyticsErrorBoundaryErrorInfo = {
+    componentStack: string;
+};
+export declare class ErrorBoundaryWithEditorView extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    featureFlags: FeatureFlags;
+    browserExtensions?: UserBrowserExtensionResults;
+    experienceStore?: ExperienceStore;
+    static defaultProps: {
+        rethrow: boolean;
+        errorTracking: boolean;
+    };
+    state: {
+        error: undefined;
+    };
+    constructor(props: ErrorBoundaryProps);
+    private sendErrorData;
+    private getProductName;
+    private fireAnalyticsEvent;
+    private getExperienceMetadata;
+    componentDidCatch(error: Error, errorInfo: AnalyticsErrorBoundaryErrorInfo): void;
+    componentDidMount(): Promise<void>;
+    render(): JSX.Element;
+}
+declare const _default: React.ComponentType<Omit<ErrorBoundaryProps, "editorView">>;
+export default _default;

package/dist/types-ts4.5/create-editor/ReactEditorView.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { ReactEditorView as BaseReactEditorView } from './ReactEditorViewInternal';
+export declare class ReactEditorView<T = {}> extends BaseReactEditorView<T> {
+}
+declare const _default: import("react").FC<import("react-intl-next").WithIntlProps<import("./ReactEditorViewInternal").EditorViewProps & import("react-intl-next").WrappedComponentProps<"intl">>> & {
+    WrappedComponent: import("react").ComponentType<import("./ReactEditorViewInternal").EditorViewProps & import("react-intl-next").WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/create-editor/ReactEditorViewContext.d.ts

@@ -0,0 +1,2 @@
+import { ReactEditorViewContext } from '@atlaskit/editor-common/ui-react';
+export default ReactEditorViewContext;

package/dist/types-ts4.5/create-editor/ReactEditorViewInternal.d.ts

@@ -0,0 +1,119 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { DirectEditorProps } from '@atlaskit/editor-prosemirror/view';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { ErrorReporter, SEVERITY } from '@atlaskit/editor-common/utils';
+import { ExperienceStore } from '@atlaskit/editor-common/ufo';
+import type { Transformer, AllEditorPresetPluginTypes } from '@atlaskit/editor-common/types';
+import type { Dispatch } from '../event-dispatcher';
+import { EventDispatcher } from '../event-dispatcher';
+import { FULL_WIDTH_MODE } from '@atlaskit/editor-common/analytics';
+import type { EditorAppearance, EditorConfig, EditorReactContext, EditorPlugin, EditorProps } from '../types';
+import type { EditorNextProps } from '../types/editor-props';
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
+import type { SetEditorAPI } from '../presets/context';
+import { TransactionTracker } from '../utils/performance/track-transactions';
+import type { FireAnalyticsCallback, AnalyticsEventPayload, DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { EditorPresetBuilder } from '@atlaskit/editor-common/preset';
+export interface EditorViewProps {
+    editorProps: EditorProps | EditorNextProps;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    providerFactory: ProviderFactory;
+    portalProviderAPI: PortalProviderAPI;
+    disabled?: boolean;
+    experienceStore?: ExperienceStore;
+    setEditorApi?: SetEditorAPI;
+    render?: (props: {
+        editor: JSX.Element;
+        view?: EditorView;
+        config: EditorConfig;
+        eventDispatcher: EventDispatcher;
+        transformer?: Transformer<string>;
+        dispatchAnalyticsEvent: DispatchAnalyticsEvent;
+        editorRef: React.RefObject<HTMLDivElement>;
+    }) => JSX.Element;
+    onEditorCreated: (instance: {
+        view: EditorView;
+        config: EditorConfig;
+        eventDispatcher: EventDispatcher;
+        transformer?: Transformer<string>;
+    }) => void;
+    onEditorDestroyed: (instance: {
+        view: EditorView;
+        config: EditorConfig;
+        eventDispatcher: EventDispatcher;
+        transformer?: Transformer<string>;
+    }) => void;
+    preset: EditorPresetBuilder<string[], AllEditorPresetPluginTypes[]>;
+}
+interface CreateEditorStateOptions {
+    props: EditorViewProps;
+    context: EditorReactContext;
+    doc?: string | Object | PMNode;
+    resetting?: boolean;
+    selectionAtStart?: boolean;
+}
+export declare class ReactEditorView<T = {}> extends React.Component<EditorViewProps & WrappedComponentProps & T, {}, EditorReactContext> {
+    view?: EditorView;
+    eventDispatcher: EventDispatcher;
+    contentTransformer?: Transformer<string>;
+    config: EditorConfig;
+    editorState: EditorState;
+    errorReporter: ErrorReporter;
+    dispatch: Dispatch;
+    proseMirrorRenderedSeverity?: SEVERITY;
+    transactionTracker: TransactionTracker;
+    validTransactionCount: number;
+    experienceStore?: ExperienceStore;
+    editorRef: React.RefObject<HTMLDivElement>;
+    static contextTypes: {
+        getAtlaskitAnalyticsEventHandlers: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    private canDispatchTransactions;
+    private focusTimeoutId?;
+    private reliabilityInterval?;
+    private pluginPerformanceObserver;
+    private featureFlags;
+    private pluginInjectionAPI;
+    private onPluginObservation;
+    get transactionTracking(): import("@atlaskit/editor-common/types").TransactionTracking;
+    private getPluginNames;
+    private countNodes;
+    private isTransactionTrackingExplicitlyDisabled;
+    constructor(props: EditorViewProps & WrappedComponentProps & T, context: EditorReactContext);
+    getEditorState: () => EditorState | undefined;
+    getEditorView: () => EditorView | undefined;
+    UNSAFE_componentWillReceiveProps(nextProps: EditorViewProps): void;
+    formatFullWidthAppearance: (appearance: EditorAppearance | undefined) => FULL_WIDTH_MODE;
+    resetEditorState: ({ doc, shouldScrollToBottom, }: {
+        doc: string;
+        shouldScrollToBottom: boolean;
+    }) => void;
+    blur: () => void;
+    reconfigureState(props: EditorViewProps): void;
+    handleAnalyticsEvent: FireAnalyticsCallback;
+    componentDidMount(): void;
+    /**
+     * Clean up any non-PM resources when the editor is unmounted
+     */
+    componentWillUnmount(): void;
+    private editorPlugins;
+    getPlugins(preset: EditorPresetBuilder<string[], AllEditorPresetPluginTypes[]>): EditorPlugin[];
+    createEditorState: (options: CreateEditorStateOptions) => EditorState;
+    private onEditorViewStateUpdated;
+    private trackValidTransactions;
+    private dispatchTransaction;
+    getDirectEditorProps: (state?: EditorState) => DirectEditorProps;
+    private createEditorView;
+    handleEditorViewRef: (node: HTMLDivElement) => void;
+    dispatchAnalyticsEvent: (payload: AnalyticsEventPayload) => void;
+    private createEditor;
+    private editor;
+    render(): JSX.Element;
+}
+export {};

package/dist/types-ts4.5/create-editor/ReactEditorViewNext.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { EditorViewProps } from './ReactEditorViewInternal';
+import { WrappedComponentProps } from 'react-intl-next';
+export declare function ReactEditorViewEditor<T = {}>(props: EditorViewProps & WrappedComponentProps & T): JSX.Element;
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<EditorViewProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<EditorViewProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/create-editor/WithEditorView.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentType } from 'react';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+export interface WithEditorViewInternalProps {
+    editorView?: EditorView | undefined;
+}
+export declare const WithEditorView: <P extends WithEditorViewInternalProps>(WrappedComponent: ComponentType<P>) => ComponentType<Omit<P, "editorView">>;

package/dist/types-ts4.5/create-editor/consts.d.ts

@@ -0,0 +1,3 @@
+export declare const PROSEMIRROR_RENDERED_NORMAL_SEVERITY_THRESHOLD = 2000;
+export declare const PROSEMIRROR_RENDERED_DEGRADED_SEVERITY_THRESHOLD = 3000;
+export declare const DEFAULT_SAMPLING_RATE_VALID_TRANSACTIONS = 100;

package/dist/types-ts4.5/create-editor/create-editor.d.ts

@@ -0,0 +1,18 @@
+import type { MarkSpec } from '@atlaskit/editor-prosemirror/model';
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { ErrorReporter } from '@atlaskit/editor-common/utils';
+import type { ErrorReportingHandler } from '@atlaskit/editor-common/utils';
+import type { EditorConfig, EditorPlugin, PMPluginCreateConfig } from '../types';
+export declare function sortByRank(a: {
+    rank: number;
+}, b: {
+    rank: number;
+}): number;
+export declare function fixExcludes(marks: {
+    [key: string]: MarkSpec;
+}): {
+    [key: string]: MarkSpec;
+};
+export declare function processPluginsList(plugins: EditorPlugin[]): EditorConfig;
+export declare function createPMPlugins(config: PMPluginCreateConfig): SafePlugin[];
+export declare function createErrorReporter(errorReporterHandler?: ErrorReportingHandler): ErrorReporter;

package/dist/types-ts4.5/create-editor/create-plugins-list.d.ts

@@ -0,0 +1,16 @@
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { EditorPlugin, EditorProps } from '../types';
+import type { EditorPluginFeatureProps } from '../types/editor-props';
+import type { ScrollGutterPluginOptions } from '@atlaskit/editor-plugin-base';
+import type { DefaultPresetPluginOptions } from '../labs/next/presets/default';
+import type { EditorPresetProps } from '../labs/next/presets/types';
+import type { EditorPresetBuilder, EditorPluginInjectionAPI } from '@atlaskit/editor-common/preset';
+export declare function getScrollGutterOptions(props: EditorProps): ScrollGutterPluginOptions | undefined;
+export declare function getDefaultPresetOptionsFromEditorProps(props: EditorProps, createAnalyticsEvent?: CreateUIAnalyticsEvent): EditorPresetProps & DefaultPresetPluginOptions & EditorPluginFeatureProps;
+/**
+ * Maps EditorProps to EditorPlugins
+ *
+ * Note: The order that presets are added determines
+ * their placement in the editor toolbar
+ */
+export default function createPluginsList(preset: EditorPresetBuilder<any, any>, props: EditorProps, pluginInjectionAPI?: EditorPluginInjectionAPI): EditorPlugin[];

package/dist/types-ts4.5/create-editor/create-preset.d.ts

@@ -0,0 +1,3 @@
+import type { EditorProps } from '../types';
+import type { EditorPresetBuilder } from '@atlaskit/editor-common/preset';
+export declare function createPreset(props: EditorProps, prevProps?: EditorProps): EditorPresetBuilder<any, any>;

package/dist/types-ts4.5/create-editor/create-schema.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from '@atlaskit/editor-prosemirror/model';
+import type { MarkConfig, NodeConfig } from '../types/pm-config';
+export declare function createSchema(editorConfig: {
+    marks: MarkConfig[];
+    nodes: NodeConfig[];
+}): Schema<string, string>;

package/dist/types-ts4.5/create-editor/feature-flags-from-props.d.ts

@@ -0,0 +1,7 @@
+import type { EditorProps } from '../types';
+import type { FeatureFlags } from '../types/feature-flags';
+/**
+ * Transforms EditorProps to an FeatureFlags object,
+ * which is used by both current and archv3 editors.
+ */
+export declare function createFeatureFlagsFromProps(props: EditorProps): FeatureFlags;