@atlaskit/editor-common 76.33.2 → 76.35.0

package/dist/esm/media-inline/media-inline-image-card.js

@@ -19,7 +19,8 @@ export var MediaInlineImageCardInternal = function MediaInlineImageCardInternal(
     isLazy = _ref.isLazy,
     width = _ref.width,
     height = _ref.height,
-    border = _ref.border;
+    border = _ref.border,
+    ssr = _ref.ssr;
   var _useState = useState(),
     _useState2 = _slicedToArray(_useState, 2),
     fileState = _useState2[0],
@@ -33,21 +34,23 @@ export var MediaInlineImageCardInternal = function MediaInlineImageCardInternal(
     }),
     formatMessage = _ref2.formatMessage;
   useEffect(function () {
-    var subscription = mediaClient.file.getFileState(identifier.id, {
-      collectionName: identifier.collectionName
-    }).subscribe({
-      next: function next(fileState) {
-        setFileState(fileState);
-        setSubscribeError(undefined);
-      },
-      error: function error(e) {
-        setSubscribeError(e);
-      }
-    });
-    return function () {
-      subscription.unsubscribe();
-    };
-  }, [identifier.collectionName, identifier.id, mediaClient.file]);
+    if (mediaClient) {
+      var subscription = mediaClient.file.getFileState(identifier.id, {
+        collectionName: identifier.collectionName
+      }).subscribe({
+        next: function next(fileState) {
+          setFileState(fileState);
+          setSubscribeError(undefined);
+        },
+        error: function error(e) {
+          setSubscribeError(e);
+        }
+      });
+      return function () {
+        subscription.unsubscribe();
+      };
+    }
+  }, [identifier, mediaClient]);
   var content = function content(dimensions) {
     if (subscribeError) {
       var isUploading = (fileState === null || fileState === void 0 ? void 0 : fileState.status) === 'uploading';
@@ -72,18 +75,20 @@ export var MediaInlineImageCardInternal = function MediaInlineImageCardInternal(
         message: formatMessage(messages.unableToLoadContent)
       });
     }
+    var mediaClientConfig = (ssr === null || ssr === void 0 ? void 0 : ssr.config) || (mediaClient === null || mediaClient === void 0 ? void 0 : mediaClient.mediaClientConfig);
     if (!fileState) {
       return jsx(InlineImageCardLoadingView, null);
     }
     return jsx(Card, {
-      mediaClientConfig: mediaClient.mediaClientConfig,
+      mediaClientConfig: mediaClientConfig,
       isLazy: isLazy,
       identifier: identifier,
       dimensions: dimensions,
       selectable: true,
       disableOverlay: true,
       selected: isSelected,
-      alt: alt
+      alt: alt,
+      ssr: ssr === null || ssr === void 0 ? void 0 : ssr.mode
     });
   };
   var aspectRatio = useMemo(function () {
@@ -92,7 +97,7 @@ export var MediaInlineImageCardInternal = function MediaInlineImageCardInternal(
 
   /**
    * scaledDimensions is used to define the correct media size fetched from media service
-   * inline images will only ever be rendererd at a maximum height of H1 and so scaled dimensions
+   * inline images will only ever be rendered at a maximum height of H1 and so scaled dimensions
    * will only ever return a width and height where the height has a maximum height of H1
    */
   var scaledDimension = useMemo(function () {

package/dist/esm/monitoring/error.js

@@ -6,7 +6,7 @@ function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbol
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 var SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 var packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-var packageVersion = "76.33.2";
+var packageVersion = "76.35.0";
 var sanitiseSentryEvents = function sanitiseSentryEvents(data, _hint) {
   // Remove URL as it has UGC
   // TODO: Sanitise the URL instead of just removing it
@@ -65,13 +65,14 @@ export var logException = /*#__PURE__*/function () {
           hub = getCurrentHub();
           hub.bindClient(client);
           hub.withScope(function (scope) {
+            var _buildInfo;
             scope.setTags(_objectSpread({
               // Jira environment variables
               'jira-bundler': window.BUNDLER_VERSION,
               'jira-variant': window.BUILD_VARIANT,
               'jira-release': window.BUILD_KEY,
               // Confluence environment variables
-              'confluence-frontend-version': window.__buildInfo.FRONTEND_VERSION
+              'confluence-frontend-version': (_buildInfo = window.__buildInfo) === null || _buildInfo === void 0 ? void 0 : _buildInfo.FRONTEND_VERSION
             }, tags));
             // Explicitly remove the breadcrumbs as it's too likely to log UGC/PII to side-step the hub integrations not being respected
             scope.clearBreadcrumbs();

package/dist/esm/ui/DropList/index.js

@@ -17,7 +17,7 @@ import { createAndFireEvent, withAnalyticsContext, withAnalyticsEvents } from '@
 import { N0, N50A, N60A, N900 } from '@atlaskit/theme/colors';
 import Layer from '../Layer';
 var packageName = "@atlaskit/editor-common";
-var packageVersion = "76.33.2";
+var packageVersion = "76.35.0";
 var halfFocusRing = 1;
 var dropOffset = '0, 8';
 var DropList = /*#__PURE__*/function (_Component) {

package/dist/esm/utils/index.js

@@ -216,6 +216,7 @@ export function isInEmptyLine(state) {
 }
 export { dedupe } from './dedupe';
 export { createWrapSelectionTransaction } from './create-wrap-selection-transaction';
+export { transformNodeIntoListItem } from './insert-node-into-ordered-list';
 export { wrapSelectionIn } from './wrap-selection-in';
 export { toJSON, nodeToJSON } from './nodes';
 export { calculateToolbarPositionAboveSelection, calculateToolbarPositionTrackHead } from './calculate-toolbar-position';

package/dist/esm/utils/insert-node-into-ordered-list.js

@@ -0,0 +1,84 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { findParentNodeOfType, findParentNodeOfTypeClosestToPos, safeInsert } from '@atlaskit/editor-prosemirror/utils';
+import { isListNode } from './list';
+export function transformNodeIntoListItem(tr, node) {
+  var _tr$doc$nodeAt, _findParentNodeOfType;
+  var _tr$selection = tr.selection,
+    $to = _tr$selection.$to,
+    $from = _tr$selection.$from,
+    to = _tr$selection.to,
+    from = _tr$selection.from;
+  var _tr$doc$type$schema$n = tr.doc.type.schema.nodes,
+    orderedList = _tr$doc$type$schema$n.orderedList,
+    bulletList = _tr$doc$type$schema$n.bulletList,
+    listItem = _tr$doc$type$schema$n.listItem;
+  var startLinePosition = $from.start();
+  var parentStartPosition = $from.depth === 0 ? 0 : $from.before();
+
+  // Setting the start position
+  var startMapped = startLinePosition === from ? parentStartPosition : from;
+
+  // Selected nodes
+  var selectionParentListItemNode = findParentNodeOfType(listItem)(tr.selection);
+  var selectionParentListNodeWithPos = findParentNodeOfType([bulletList, orderedList])(tr.selection);
+  var selectionParentListNode = selectionParentListNodeWithPos === null || selectionParentListNodeWithPos === void 0 ? void 0 : selectionParentListNodeWithPos.node;
+  if (!selectionParentListNodeWithPos) {
+    return tr;
+  }
+
+  // Offsets
+  var listWrappingOffset = $to.depth - selectionParentListNodeWithPos.depth + 1; // difference in depth between to position and list node
+  var listItemWrappingOffset = $to.depth - selectionParentListNodeWithPos.depth; // difference in depth between to position and list item node
+
+  // Anything to do with nested lists should safeInsert and not be handled here
+  var grandParentListNode = findParentNodeOfTypeClosestToPos(tr.doc.resolve(selectionParentListNodeWithPos.pos), [bulletList, orderedList]);
+  var selectionIsInNestedList = !!grandParentListNode;
+  var selectedListItemHasNestedList = false;
+  selectionParentListItemNode === null || selectionParentListItemNode === void 0 || selectionParentListItemNode.node.content.forEach(function (child) {
+    if (isListNode(child)) {
+      selectedListItemHasNestedList = true;
+    }
+  });
+  if (selectedListItemHasNestedList || selectionIsInNestedList) {
+    return safeInsert(node)(tr).scrollIntoView();
+  }
+
+  // Check if node after the insert position is listItem
+  var isNodeAfterInsertPositionIsListItem = ((_tr$doc$nodeAt = tr.doc.nodeAt(to + listItemWrappingOffset)) === null || _tr$doc$nodeAt === void 0 ? void 0 : _tr$doc$nodeAt.type) === listItem;
+  var replaceTo;
+  if (isNodeAfterInsertPositionIsListItem) {
+    replaceTo = to + listItemWrappingOffset;
+  } else if (!isNodeAfterInsertPositionIsListItem) {
+    replaceTo = to;
+  } else {
+    replaceTo = to + listWrappingOffset;
+  }
+
+  // handle the insertion of the slice
+  tr.replaceWith(startMapped, replaceTo, node).scrollIntoView();
+
+  // Get the next list items position (used later to find the split out ordered list)
+  var indexOfNextListItem = $to.indexAfter($to.depth - listItemWrappingOffset);
+  var positionOfNextListItem = tr.doc.resolve(selectionParentListNodeWithPos.pos + 1).posAtIndex(indexOfNextListItem);
+
+  // Find the ordered list node after the pasted content so we can set it's order
+  var mappedPositionOfNextListItem = tr.mapping.map(positionOfNextListItem);
+  if (mappedPositionOfNextListItem > tr.doc.nodeSize) {
+    return tr;
+  }
+  var nodeAfterPastedContentResolvedPos = findParentNodeOfTypeClosestToPos(tr.doc.resolve(mappedPositionOfNextListItem), [orderedList]);
+
+  // Work out the new split out lists 'order' (the number it starts from)
+  var originalParentOrderedListNodeOrder = selectionParentListNode === null || selectionParentListNode === void 0 ? void 0 : selectionParentListNode.attrs.order;
+  var numOfListItemsInOriginalList = (_findParentNodeOfType = findParentNodeOfTypeClosestToPos(tr.doc.resolve(from - 1), [orderedList])) === null || _findParentNodeOfType === void 0 ? void 0 : _findParentNodeOfType.node.childCount;
+
+  // Set the new split out lists order attribute
+  if (typeof originalParentOrderedListNodeOrder === 'number' && numOfListItemsInOriginalList && nodeAfterPastedContentResolvedPos) {
+    tr.setNodeMarkup(nodeAfterPastedContentResolvedPos.pos, orderedList, _objectSpread(_objectSpread({}, nodeAfterPastedContentResolvedPos.node.attrs), {}, {
+      order: originalParentOrderedListNodeOrder + numOfListItemsInOriginalList
+    }));
+  }
+  return tr;
+}

package/dist/types/collab/index.d.ts

@@ -376,4 +376,11 @@ export interface CollabAnalyticsProps {
 export interface CollabEventLocalStepData {
     steps: Array<Step>;
 }
+export interface Color {
+    solid: string;
+    selection: string;
+}
+export declare const colors: Color[];
+export declare const TELEPOINTER_DIM_CLASS = "telepointer-dim";
+export declare const telepointerStyle: import("@emotion/react").SerializedStyles;
 export {};

package/dist/types/core-utils/document-logger.d.ts

@@ -0,0 +1,6 @@
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { SimplifiedNode } from '../analytics';
+export type { SimplifiedNode };
+export declare const getDocStructure: (doc: PMNode, options?: {
+    compact?: boolean;
+}) => SimplifiedNode | string;

package/dist/types/core-utils/index.d.ts

@@ -1 +1,2 @@
 export { insideTable } from './inside';
+export { getDocStructure } from './document-logger';

package/dist/types/extensibility/Extension/Extension/index.d.ts

@@ -0,0 +1,108 @@
+import React from 'react';
+import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { ExtensionProvider, ReferenceEntity } from '../../../extensions';
+import type { ProsemirrorGetPosHandler } from '../../../react-node-view';
+import type { EditorAppearance } from '../../../types';
+import type { ExtensionsPluginInjectionAPI } from '../../types';
+export interface Props {
+    node: PmNode;
+    getPos: ProsemirrorGetPosHandler;
+    view: EditorView;
+    extensionProvider?: ExtensionProvider;
+    handleContentDOMRef: (node: HTMLElement | null) => void;
+    children?: React.ReactNode;
+    references?: ReferenceEntity[];
+    hideFrame?: boolean;
+    editorAppearance?: EditorAppearance;
+    pluginInjectionApi: ExtensionsPluginInjectionAPI;
+}
+/**
+ * End workaround
+ */
+declare const _default: {
+    new (props: Props | Readonly<Props>): {
+        overflowContainer?: HTMLElement | null | undefined;
+        container?: HTMLElement | undefined;
+        shadowObserver?: import("../../../ui").ShadowObserver | undefined;
+        overflowContainerWidth: number;
+        scrollable?: NodeList | undefined;
+        diff?: number | undefined;
+        state: {
+            showLeftShadow: boolean;
+            showRightShadow: boolean;
+        };
+        componentWillUnmount(): void;
+        componentDidUpdate(): void;
+        handleScroll: (event: Event) => void;
+        updateShadows: () => void;
+        showLeftShadow: (overflowContainer: HTMLElement | null | undefined) => boolean;
+        calcOverflowDiff: () => number;
+        calcScrollableWidth: () => number;
+        handleContainer: (container: HTMLElement | null) => void;
+        initShadowObserver(): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends keyof import("../../../ui").OverflowShadowState>(state: import("../../../ui").OverflowShadowState | ((prevState: Readonly<import("../../../ui").OverflowShadowState>, props: Readonly<Props>) => import("../../../ui").OverflowShadowState | Pick<import("../../../ui").OverflowShadowState, K> | null) | Pick<import("../../../ui").OverflowShadowState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Props> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<import("../../../ui").OverflowShadowState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<import("../../../ui").OverflowShadowState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<import("../../../ui").OverflowShadowState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<import("../../../ui").OverflowShadowState>, nextContext: any): void;
+    };
+    new (props: Props, context: any): {
+        overflowContainer?: HTMLElement | null | undefined;
+        container?: HTMLElement | undefined;
+        shadowObserver?: import("../../../ui").ShadowObserver | undefined;
+        overflowContainerWidth: number;
+        scrollable?: NodeList | undefined;
+        diff?: number | undefined;
+        state: {
+            showLeftShadow: boolean;
+            showRightShadow: boolean;
+        };
+        componentWillUnmount(): void;
+        componentDidUpdate(): void;
+        handleScroll: (event: Event) => void;
+        updateShadows: () => void;
+        showLeftShadow: (overflowContainer: HTMLElement | null | undefined) => boolean;
+        calcOverflowDiff: () => number;
+        calcScrollableWidth: () => number;
+        handleContainer: (container: HTMLElement | null) => void;
+        initShadowObserver(): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends keyof import("../../../ui").OverflowShadowState>(state: import("../../../ui").OverflowShadowState | ((prevState: Readonly<import("../../../ui").OverflowShadowState>, props: Readonly<Props>) => import("../../../ui").OverflowShadowState | Pick<import("../../../ui").OverflowShadowState, K> | null) | Pick<import("../../../ui").OverflowShadowState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Props> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<import("../../../ui").OverflowShadowState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<import("../../../ui").OverflowShadowState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<import("../../../ui").OverflowShadowState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<import("../../../ui").OverflowShadowState>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/types/extensibility/Extension/Extension/styles.d.ts

@@ -0,0 +1,5 @@
+export declare const widerLayoutClassName = "wider-layout";
+export declare const wrapperStyle: import("@emotion/react").SerializedStyles;
+export declare const header: import("@emotion/react").SerializedStyles;
+export declare const content: import("@emotion/react").SerializedStyles;
+export declare const contentWrapper: import("@emotion/react").SerializedStyles;

package/dist/types/extensibility/Extension/InlineExtension/index.d.ts

@@ -0,0 +1,12 @@
+/** @jsx jsx */
+import React from 'react';
+import { Component } from 'react';
+import { jsx } from '@emotion/react';
+import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
+export interface Props {
+    node: PmNode;
+    children?: React.ReactNode;
+}
+export default class InlineExtension extends Component<Props, any> {
+    render(): jsx.JSX.Element;
+}

package/dist/types/extensibility/Extension/InlineExtension/styles.d.ts

@@ -0,0 +1 @@
+export declare const wrapperStyle: import("@emotion/react").SerializedStyles;

package/dist/types/extensibility/Extension/Lozenge.d.ts

@@ -0,0 +1,14 @@
+/** @jsx jsx */
+import { Component } from 'react';
+import { jsx } from '@emotion/react';
+import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
+export declare const capitalizeFirstLetter: (str: string) => string;
+export interface Props {
+    node: PmNode;
+}
+export declare const ICON_SIZE = 24;
+export default class ExtensionLozenge extends Component<Props, any> {
+    render(): jsx.JSX.Element;
+    private renderImage;
+    private renderFallback;
+}

package/dist/types/extensibility/Extension/styles.d.ts

@@ -0,0 +1,7 @@
+import { BODIED_EXT_PADDING, EXTENSION_PADDING } from '../../styles';
+export { EXTENSION_PADDING as padding, BODIED_EXT_PADDING };
+export declare const wrapperDefault: import("@emotion/react").SerializedStyles;
+export declare const overlay: import("@emotion/react").SerializedStyles;
+export declare const placeholderFallback: import("@emotion/react").SerializedStyles;
+export declare const placeholderFallbackParams: import("@emotion/react").SerializedStyles;
+export declare const styledImage: import("@emotion/react").SerializedStyles;

package/dist/types/extensibility/Extension.d.ts

@@ -0,0 +1,29 @@
+import { Component } from 'react';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { EventDispatcher } from '../event-dispatcher';
+import type { ExtensionHandlers, ReferenceEntity } from '../extensions';
+import { ProviderFactory } from '../provider-factory';
+import type { ProsemirrorGetPosHandler } from '../react-node-view';
+import type { EditorAppearance } from '../types';
+import type { ExtensionsPluginInjectionAPI } from './types';
+export interface Props {
+    editorView: EditorView;
+    node: PMNode;
+    getPos: ProsemirrorGetPosHandler;
+    providerFactory?: ProviderFactory;
+    handleContentDOMRef: (node: HTMLElement | null) => void;
+    extensionHandlers: ExtensionHandlers;
+    references?: ReferenceEntity[];
+    editorAppearance?: EditorAppearance;
+    pluginInjectionApi: ExtensionsPluginInjectionAPI;
+    eventDispatcher?: EventDispatcher;
+}
+export declare class Extension extends Component<Props, any> {
+    static displayName: string;
+    private providerFactory;
+    constructor(props: Props);
+    componentWillUnmount(): void;
+    private renderWithProvider;
+    render(): JSX.Element;
+}

package/dist/types/extensibility/ExtensionComponent.d.ts

@@ -0,0 +1,53 @@
+import { Component } from 'react';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { EventDispatcher } from '../event-dispatcher';
+import { getExtensionModuleNodePrivateProps, getNodeRenderer } from '../extensions';
+import type { ExtensionHandlers, ExtensionProvider, ReferenceEntity } from '../extensions';
+import type { ProsemirrorGetPosHandler } from '../react-node-view';
+import type { EditorAppearance } from '../types';
+import type { ExtensionsPluginInjectionAPI } from './types';
+export interface Props {
+    editorView: EditorView;
+    node: PMNode;
+    getPos: ProsemirrorGetPosHandler;
+    handleContentDOMRef: (node: HTMLElement | null) => void;
+    extensionHandlers: ExtensionHandlers;
+    extensionProvider?: Promise<ExtensionProvider>;
+    references?: ReferenceEntity[];
+    editorAppearance?: EditorAppearance;
+    pluginInjectionApi: ExtensionsPluginInjectionAPI;
+    eventDispatcher?: EventDispatcher;
+}
+export interface State {
+    extensionProvider?: ExtensionProvider;
+    extensionHandlersFromProvider?: ExtensionHandlers;
+    _privateProps?: {
+        __hideFrame?: boolean;
+    };
+    activeChildIndex?: number;
+}
+export declare class ExtensionComponent extends Component<Props, State> {
+    private privatePropsParsed;
+    state: State;
+    mounted: boolean;
+    UNSAFE_componentWillMount(): void;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    getNodeRenderer: import("memoize-one").MemoizedFn<typeof getNodeRenderer>;
+    getExtensionModuleNodePrivateProps: import("memoize-one").MemoizedFn<typeof getExtensionModuleNodePrivateProps>;
+    render(): JSX.Element | null;
+    private setStateFromPromise;
+    /**
+     * Parses any private nodes once an extension provider is available.
+     *
+     * We do this separately from resolving a node renderer component since the
+     * private props come from extension provider, rather than an extension
+     * handler which only handles `render`/component concerns.
+     */
+    private parsePrivateNodePropsIfNeeded;
+    private tryExtensionHandler;
+    private handleExtension;
+}

package/dist/types/extensibility/ExtensionNodeWrapper.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+type Props = {
+    children: React.ReactNode;
+    nodeType: string;
+};
+/**
+ * If inlineExtension, add zero width space to the end of the nodes and wrap with span;
+ * else wrap with a div (for multi bodied extensions)
+ *
+ * @param param0
+ * @returns
+ */
+export declare const ExtensionNodeWrapper: ({ children, nodeType }: Props) => JSX.Element;
+export {};

package/dist/types/extensibility/MultiBodiedExtension/index.d.ts

@@ -0,0 +1,26 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { EventDispatcher } from '../../event-dispatcher';
+import type { MultiBodiedExtensionActions } from '../../extensions';
+import type { EditorAppearance } from '../../types';
+import type { OverflowShadowProps } from '../../ui';
+import type { ExtensionsPluginInjectionAPI } from '../types';
+export type TryExtensionHandlerType = (actions: MultiBodiedExtensionActions | undefined) => React.ReactElement | null;
+type Props = {
+    node: PmNode;
+    handleContentDOMRef: (node: HTMLElement | null) => void;
+    editorView: EditorView;
+    getPos: () => number | undefined;
+    tryExtensionHandler: TryExtensionHandlerType;
+    eventDispatcher?: EventDispatcher;
+    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
+    editorAppearance?: EditorAppearance;
+};
+declare const MultiBodiedExtension: (props: Props & OverflowShadowProps) => jsx.JSX.Element;
+/**
+ * End workaround
+ */
+export default MultiBodiedExtension;

package/dist/types/extensibility/extensionNodeView.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="react" />
+import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView, NodeView } from '@atlaskit/editor-prosemirror/view';
+import type { EventDispatcher } from '../event-dispatcher';
+import type { ExtensionHandlers } from '../extensions';
+import type { ProviderFactory } from '../provider-factory';
+import type { ForwardRef, getPosHandler } from '../react-node-view';
+import ReactNodeView from '../react-node-view';
+import type { EditorAppearance } from '../types';
+import type { PortalProviderAPI } from '../ui/PortalProvider';
+import type { ExtensionsPluginInjectionAPI } from './types';
+interface ExtensionNodeViewOptions {
+    appearance?: EditorAppearance;
+}
+export declare class ExtensionNode extends ReactNodeView {
+    ignoreMutation(mutation: MutationRecord | {
+        type: 'selection';
+        target: Element;
+    }): boolean;
+    getContentDOM(): {
+        dom: HTMLDivElement;
+    } | undefined;
+    render(props: {
+        providerFactory: ProviderFactory;
+        extensionHandlers: ExtensionHandlers;
+        extensionNodeViewOptions?: ExtensionNodeViewOptions;
+        pluginInjectionApi: ExtensionsPluginInjectionAPI;
+    }, forwardRef: ForwardRef): JSX.Element;
+}
+export default function ExtensionNodeView(portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory, extensionHandlers: ExtensionHandlers, extensionNodeViewOptions: ExtensionNodeViewOptions, pluginInjectionApi: ExtensionsPluginInjectionAPI): (node: PmNode, view: EditorView, getPos: getPosHandler) => NodeView;
+export {};

package/dist/types/extensibility/index.d.ts

@@ -0,0 +1,4 @@
+export { ExtensionNodeWrapper } from './ExtensionNodeWrapper';
+export { Extension } from './Extension';
+export { default as ExtensionNodeView, ExtensionNode, } from './extensionNodeView';
+export { ExtensionComponent } from './ExtensionComponent';

package/dist/types/extensibility/types.d.ts

@@ -0,0 +1,6 @@
+import type { EditorContainerWidth, NextEditorPlugin, PublicPluginAPI } from '../types';
+type WidthPluginType = NextEditorPlugin<'width', {
+    sharedState: EditorContainerWidth | undefined;
+}>;
+export type ExtensionsPluginInjectionAPI = PublicPluginAPI<[WidthPluginType]> | undefined;
+export {};

package/dist/types/extensions/types/extension-handler.d.ts

@@ -9,6 +9,8 @@ export interface ExtensionParams<T extends Parameters> {
     content?: object | string;
     localId?: string;
     fragmentLocalId?: string;
+    maxFrames?: number;
+    layout?: string;
 }
 export type ExtensionHandler<T extends Parameters = Parameters> = (ext: ExtensionParams<T>, doc: object, actions?: MultiBodiedExtensionActions) => JSX.Element | null;
 export type OnSaveCallback<T extends Parameters = Parameters> = (params: T) => void;

package/dist/types/media-inline/media-inline-image-card.d.ts

@@ -2,16 +2,17 @@
 import type { FC } from 'react';
 import type { WrappedComponentProps } from 'react-intl-next';
 import type { FileIdentifier, MediaClient } from '@atlaskit/media-client';
-import type { MediaInlineAttrs } from './types';
+import type { MediaInlineAttrs, MediaSSR } from './types';
 export interface MediaInlineImageCardProps {
     identifier: FileIdentifier;
-    mediaClient: MediaClient;
+    mediaClient?: MediaClient;
     isSelected?: boolean;
     isLazy?: boolean;
     border?: {
         borderSize?: number;
         borderColor?: string;
     };
+    ssr?: MediaSSR;
 }
 export declare const MediaInlineImageCardInternal: FC<MediaInlineImageCardProps & WrappedComponentProps & MediaInlineAttrs>;
 export declare const MediaInlineImageCard: FC<MediaInlineImageCardProps & MediaInlineAttrs>;

package/dist/types/media-inline/types.d.ts

@@ -1,8 +1,12 @@
+import type { SSR } from '@atlaskit/media-common';
+import type { MediaClientConfig } from '@atlaskit/media-core';
 export type MediaInlineAttrs = {
     type?: string;
     alt?: string;
     width?: number;
     height?: number;
-    borderSize?: number;
-    borderColor?: string;
+};
+export type MediaSSR = {
+    mode: SSR;
+    config: MediaClientConfig;
 };

package/dist/types/types/index.d.ts

@@ -28,7 +28,7 @@ export type { EditorReactContext } from './editor-react-context';
 export type { PMPluginFactoryParams, PMPluginFactory, PMPlugin, } from './plugin-factory';
 export type { NodeConfig, MarkConfig, NodeViewConfig, } from './prosemirror-config';
 export type { PluginsOptions, EditorPlugin, getPosHandler, getPosHandlerNode, } from './editor-plugin';
-export type { NextEditorPlugin, AllEditorPresetPluginTypes, PluginDependenciesAPI, ExtractPluginNameFromAllBuilderPlugins, SafePresetCheck, DefaultEditorPlugin, OptionalPlugin, PluginInjectionAPI, CreatePluginDependenciesAPI, NextEditorPluginMetadata, ExtractInjectionAPI, ExtractPluginActions, PluginInjectionAPIWithDependency, PluginInjectionAPIWithDependencies, PublicPluginAPI, NextEditorPluginFunctionOptionalConfigDefinition, ExtractNextEditorPlugins, } from './next-editor-plugin';
+export type { NextEditorPlugin, AllEditorPresetPluginTypes, PluginDependenciesAPI, ExtractPluginNameFromAllBuilderPlugins, SafePresetCheck, DefaultEditorPlugin, OptionalPlugin, PluginInjectionAPI, CreatePluginDependenciesAPI, NextEditorPluginMetadata, ExtractInjectionAPI, ExtractPluginActions, PluginInjectionAPIWithDependencies, PublicPluginAPI, NextEditorPluginFunctionOptionalConfigDefinition, ExtractNextEditorPlugins, } from './next-editor-plugin';
 export type { ExtractPublicEditorAPI } from './editor-public-api';
 export type { EditorCommand, EditorCommandWithMetadata, } from './editor-command';
 export type IconProps = {

package/dist/types/types/next-editor-plugin.d.ts

@@ -46,7 +46,6 @@ export type PluginInjectionAPI<Name extends string, Metadata extends NextEditorP
         ...ExtractPluginDependenciesFromMetadata<Metadata>
     ]>;
 };
-export type PluginInjectionAPIWithDependency<Plugin extends NextEditorPlugin<any, any>> = PublicPluginAPI<[Plugin]>;
 export type PluginInjectionAPIWithDependencies<Plugins extends NextEditorPlugin<any, any>[]> = PublicPluginAPI<Plugins>;
 export type NextEditorPluginFunctionOptionalConfigDefinition<Name extends string, Metadata extends NextEditorPluginMetadata, Configuration = undefined> = (props: {
     config: Configuration;