@atlaskit/renderer 120.5.0 → 120.5.2

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @atlaskit/renderer
 
+## 120.5.2
+
+### Patch Changes
+
+- [`0fdcb6f2f96fd`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/0fdcb6f2f96fd) -
+  Sorted type and interface props to improve Atlaskit docs
+- Updated dependencies
+
+## 120.5.1
+
+### Patch Changes
+
+- [`ffc3ef708967c`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/ffc3ef708967c) -
+  [ux] Adds an optional disablePreviewPanel prop on a smartcard to allow consumers opt out of
+  opening Preview Panel by default when a smartlink is clicked.
+- Updated dependencies
+
 ## 120.5.0
 
 ### Minor Changes

package/afm-cc/tsconfig.json

@@ -3,9 +3,9 @@
 	"compilerOptions": {
 		"declaration": true,
 		"target": "es5",
-		"composite": true,
 		"outDir": "../../../../../confluence/tsDist/@atlaskit__renderer",
-		"rootDir": "../"
+		"rootDir": "../",
+		"composite": true
 	},
 	"include": [
 		"../src/**/*.ts",

package/dist/cjs/react/nodes/inlineCard.js

@@ -198,7 +198,8 @@ var InlineCard = function InlineCard(props) {
         setIsResolvedViewRendered(true);
       }
     },
-    onError: onError
+    onError: onError,
+    disablePreviewPanel: (0, _expValEquals.expValEquals)('platform_editor_preview_panel_linking_exp', 'isEnabled', true)
   }))), CompetitorPromptComponent)));
 };
 var _default = exports.default = (0, _SmartCardStorage.withSmartCardStorage)(InlineCard);

package/dist/cjs/ui/Renderer/index.js

@@ -63,7 +63,7 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 var NORMAL_SEVERITY_THRESHOLD = exports.NORMAL_SEVERITY_THRESHOLD = 2000;
 var DEGRADED_SEVERITY_THRESHOLD = exports.DEGRADED_SEVERITY_THRESHOLD = 3000;
 var packageName = "@atlaskit/renderer";
-var packageVersion = "120.4.9";
+var packageVersion = "120.5.1";
 var setAsQueryContainerStyles = (0, _react2.css)({
   containerName: 'ak-renderer-wrapper',
   containerType: 'inline-size'

package/dist/es2019/react/nodes/inlineCard.js

@@ -182,7 +182,8 @@ const InlineCard = props => {
         setIsResolvedViewRendered(true);
       }
     },
-    onError: onError
+    onError: onError,
+    disablePreviewPanel: expValEquals('platform_editor_preview_panel_linking_exp', 'isEnabled', true)
   }))), CompetitorPromptComponent)));
 };
 export default withSmartCardStorage(InlineCard);

package/dist/es2019/ui/Renderer/index.js

@@ -49,7 +49,7 @@ import { expValEqualsNoExposure } from '@atlaskit/tmp-editor-statsig/exp-val-equ
 export const NORMAL_SEVERITY_THRESHOLD = 2000;
 export const DEGRADED_SEVERITY_THRESHOLD = 3000;
 const packageName = "@atlaskit/renderer";
-const packageVersion = "120.4.9";
+const packageVersion = "120.5.1";
 const setAsQueryContainerStyles = css({
   containerName: 'ak-renderer-wrapper',
   containerType: 'inline-size'

package/dist/esm/react/nodes/inlineCard.js

@@ -189,7 +189,8 @@ var InlineCard = function InlineCard(props) {
         setIsResolvedViewRendered(true);
       }
     },
-    onError: onError
+    onError: onError,
+    disablePreviewPanel: expValEquals('platform_editor_preview_panel_linking_exp', 'isEnabled', true)
   }))), CompetitorPromptComponent)));
 };
 export default withSmartCardStorage(InlineCard);

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

@@ -54,7 +54,7 @@ import { expValEqualsNoExposure } from '@atlaskit/tmp-editor-statsig/exp-val-equ
 export var NORMAL_SEVERITY_THRESHOLD = 2000;
 export var DEGRADED_SEVERITY_THRESHOLD = 3000;
 var packageName = "@atlaskit/renderer";
-var packageVersion = "120.4.9";
+var packageVersion = "120.5.1";
 var setAsQueryContainerStyles = css({
   containerName: 'ak-renderer-wrapper',
   containerType: 'inline-size'

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

@@ -6,8 +6,8 @@ import type { Step } from '@atlaskit/editor-prosemirror/transform';
 import { RemoveMarkStep, RemoveNodeMarkStep } from '@atlaskit/editor-prosemirror/transform';
 import type { AnalyticsEventPayload } from '../analytics/events';
 type ActionResult = {
-    step: Step;
     doc: JSONDocNode;
+    step: Step;
 } | false;
 type Position = {
     from: number;
@@ -24,9 +24,9 @@ interface RendererActionsOptions {
 }
 export type ApplyAnnotation = (pos: Position, annotation: Annotation) => AnnotationActionResult;
 interface AnnotationsRendererActionsOptions {
-    isValidAnnotationPosition: (pos: Position) => boolean;
     applyAnnotation: ApplyAnnotation;
     getAnnotationMarks: () => Mark[];
+    isValidAnnotationPosition: (pos: Position) => boolean;
 }
 interface PositionRendererActionsOptions {
     getPositionFromRange: (range: Range) => Position | false;

package/dist/types/actions/matches-utils.d.ts

@@ -1,8 +1,8 @@
 import type { Node, Schema } from '@atlaskit/editor-prosemirror/model';
 export declare function getIndexMatch(doc: Node, schema: Schema, selectedText: string, startIndex: number): {
-    numMatches: number;
+    blockNodePos?: number;
     matchIndex: number;
+    numMatches: number;
     textContent: string;
-    blockNodePos?: number;
 };
 export declare function countMatches(searchString: string, query: string): number;

package/dist/types/analytics/events.d.ts

@@ -15,40 +15,40 @@ type RendererStartAEP = AEP<ACTION.STARTED, ACTION_SUBJECT.RENDERER, undefined,
     platform: PLATFORM.WEB;
 }, EVENT_TYPE.UI>;
 type RendererRenderedAEP = AEP<ACTION.RENDERED, ACTION_SUBJECT.RENDERER, undefined, {
-    platform: PLATFORM.WEB;
-    duration: number;
     distortedDuration: boolean;
-    ttfb?: number;
+    duration: number;
     nodes: Record<string, number>;
+    platform: PLATFORM.WEB;
     severity?: SEVERITY;
+    ttfb?: number;
 }, EVENT_TYPE.OPERATIONAL>;
 export type ComponentCrashErrorAEP = OperationalAEP<ACTION.CRASHED, ACTION_SUBJECT.RENDERER, ACTION_SUBJECT_ID, {
-    platform: PLATFORM.WEB;
-    errorMessage?: string;
-    errorStack?: string;
     componentStack?: string;
+    errorMessage?: string;
     errorRethrown?: boolean;
+    errorStack?: string;
+    platform: PLATFORM.WEB;
 }>;
 export type ComponentCaughtDomErrorAEP = OperationalAEP<ACTION.CAUGHT_DOM_ERROR, ACTION_SUBJECT.RENDERER, ACTION_SUBJECT_ID, {
     errorMessage: string;
     platform: PLATFORM.WEB;
 }>;
 type InvalidProsemirrorDocumentErrorAEP = AEP<ACTION.INVALID_PROSEMIRROR_DOCUMENT, ACTION_SUBJECT.RENDERER, ACTION_SUBJECT_ID, {
-    platform: PLATFORM.WEB;
     errorStack?: string;
+    platform: PLATFORM.WEB;
 }, EVENT_TYPE.OPERATIONAL>;
 type RendererUnsupportedContentLevelsTrackingSucceeded = AEP<ACTION.UNSUPPORTED_CONTENT_LEVELS_TRACKING_SUCCEEDED, ACTION_SUBJECT.RENDERER, undefined, {
     appearance?: string;
     platform: PLATFORM.WEB;
-    unsupportedContentLevelSeverity: UNSUPPORTED_CONTENT_LEVEL_SEVERITY;
+    supportedNodesCount: number;
     unsupportedContentLevelPercentage: number;
+    unsupportedContentLevelSeverity: UNSUPPORTED_CONTENT_LEVEL_SEVERITY;
     unsupportedNodesCount: number;
-    supportedNodesCount: number;
     unsupportedNodeTypeCount: Record<string, number>;
 }, EVENT_TYPE.OPERATIONAL>;
 type RendererUnsupportedContentLevelsTrackingErrored = AEP<ACTION.UNSUPPORTED_CONTENT_LEVELS_TRACKING_ERRORED, ACTION_SUBJECT.RENDERER, undefined, {
-    platform: PLATFORM.WEB;
     error: string;
+    platform: PLATFORM.WEB;
 }, EVENT_TYPE.OPERATIONAL>;
 type RendererSelectAllCaughtAEP = AEP<ACTION.SELECT_ALL_CAUGHT, ACTION_SUBJECT.RENDERER, undefined, {
     platform: PLATFORM.WEB;
@@ -59,8 +59,8 @@ type RendererSelectAllEscapedAEP = AEP<ACTION.SELECT_ALL_ESCAPED, ACTION_SUBJECT
 type UIAEP<Action, ActionSubject, ActionSubjectID, Attributes> = AEP<Action, ActionSubject, ActionSubjectID, Attributes, EVENT_TYPE.UI>;
 type ButtonAEP<ActionSubjectID, Attributes> = UIAEP<ACTION.CLICKED, ACTION_SUBJECT.BUTTON, ActionSubjectID, Attributes>;
 type AnchorLinkAEP = UIAEP<ACTION.VIEWED, ACTION_SUBJECT.ANCHOR_LINK, undefined, {
-    platform: PLATFORM.WEB;
     mode: MODE.RENDERER;
+    platform: PLATFORM.WEB;
 }>;
 type CodeBlockCopyAEP = ButtonAEP<ACTION_SUBJECT_ID.CODEBLOCK_COPY, undefined>;
 type CodeBlockWrapAEP = ButtonAEP<ACTION_SUBJECT_ID.CODEBLOCK_WRAP, {
@@ -68,27 +68,27 @@ type CodeBlockWrapAEP = ButtonAEP<ACTION_SUBJECT_ID.CODEBLOCK_WRAP, {
 }>;
 type HeadingAnchorLinkButtonAEP = ButtonAEP<ACTION_SUBJECT_ID.HEADING_ANCHOR_LINK, undefined>;
 type TableSortColumnNotAllowedAEP = AEP<ACTION.SORT_COLUMN_NOT_ALLOWED, ACTION_SUBJECT.TABLE, undefined, {
-    platform: PLATFORM.WEB;
     mode: MODE.RENDERER;
+    platform: PLATFORM.WEB;
 }, EVENT_TYPE.TRACK>;
 type TableSortColumnAEP = AEP<ACTION.SORT_COLUMN, ACTION_SUBJECT.TABLE, undefined, {
-    platform: PLATFORM.WEB;
+    columnIndex: number;
     mode: MODE.RENDERER;
+    platform: PLATFORM.WEB;
     sortOrder: SortOrder;
-    columnIndex: number;
 }, EVENT_TYPE.TRACK>;
 type VisitLinkAEP = AEP<ACTION.VISITED, ACTION_SUBJECT.LINK, undefined, {
-    platform: PLATFORM.WEB;
     mode: MODE.RENDERER;
+    platform: PLATFORM.WEB;
 }, EVENT_TYPE.TRACK>;
 type VisitMediaLinkAEP = AEP<ACTION.VISITED, ACTION_SUBJECT.MEDIA, ACTION_SUBJECT_ID.LINK, {
-    platform: PLATFORM.WEB;
     mode: MODE.RENDERER;
+    platform: PLATFORM.WEB;
 }, EVENT_TYPE.TRACK>;
 type ExpandAEP = AEP<ACTION.TOGGLE_EXPAND, ACTION_SUBJECT.EXPAND | ACTION_SUBJECT.NESTED_EXPAND, undefined, {
-    platform: PLATFORM.WEB;
-    mode: MODE.RENDERER;
     expanded: boolean;
+    mode: MODE.RENDERER;
+    platform: PLATFORM.WEB;
 }, EVENT_TYPE.TRACK>;
 type AnnotationActionType = ACTION.INSERTED | ACTION.CLOSED | ACTION.EDITED | ACTION.DELETED | ACTION.OPENED | ACTION.RESOLVED | ACTION.VIEWED | ACTION.CREATE_NOT_ALLOWED;
 type AnnotationAEPAttributes = AnnotationDraftAEPAttributes | AnnotationResolvedAEPAttributes;

package/dist/types/analytics/unsupported-content.d.ts

@@ -2,9 +2,9 @@ import type { UnsupportedContentLevelsTracking } from '@atlaskit/editor-common/u
 import type { AnalyticsEventPayload } from './events';
 type DispatchAnalyticsEvent = (event: AnalyticsEventPayload) => void;
 type DocumentData = {
-    rendererId: string;
-    doc: any;
     appearance?: string;
+    doc: any;
+    rendererId: string;
 };
 export declare const trackUnsupportedContentLevels: (item: DocumentData, trackingOptions: UnsupportedContentLevelsTracking, dispatchAnalyticsEvent: DispatchAnalyticsEvent) => void;
 export {};

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

@@ -12,47 +12,47 @@ import type { MediaOptions } from '../types/mediaOptions';
 import type { SmartLinksOptions } from '../types/smartLinksOptions';
 import type { EmojiResourceConfig } from '@atlaskit/emoji/resource';
 export interface ReactSerializerInit {
+    allowAltTextOnImages?: boolean;
+    allowAnnotations?: boolean;
+    allowColumnSorting?: boolean;
+    allowCopyToClipboard?: boolean;
+    allowCustomPanels?: boolean;
+    allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
+    allowMediaLinking?: boolean;
+    allowPlaceholderText?: boolean;
+    allowSelectAllTrap?: boolean;
+    allowTableAlignment?: boolean;
+    allowTableResizing?: boolean;
+    allowWindowedCodeBlock?: boolean;
+    allowWrapCodeBlock?: boolean;
+    appearance?: RendererAppearance;
+    disableActions?: boolean;
+    disableHeadingIDs?: boolean;
+    disableTableOverflowShadow?: boolean;
+    emojiResourceConfig?: EmojiResourceConfig;
+    eventHandlers?: EventHandlers;
+    extensionHandlers?: ExtensionHandlers;
+    extensionViewportSizes?: ExtensionViewportSize[];
+    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
+    getExtensionHeight?: GetPMNodeHeight;
+    isInsideOfInlineExtension?: boolean;
+    isPresentational?: boolean;
+    media?: MediaOptions;
+    nodeComponents?: NodeComponentsProps;
+    objectContext?: RendererContext;
+    portal?: HTMLElement;
+    providers?: ProviderFactory;
+    shouldOpenMediaViewer?: boolean;
+    smartLinks?: SmartLinksOptions;
     /**
      * Used for to set positions on nodes for annotations.
      *
      * When not provided defaults to 1.
      */
     startPos?: number;
-    providers?: ProviderFactory;
-    eventHandlers?: EventHandlers;
-    extensionHandlers?: ExtensionHandlers;
-    portal?: HTMLElement;
-    objectContext?: RendererContext;
-    appearance?: RendererAppearance;
-    disableHeadingIDs?: boolean;
-    disableActions?: boolean;
-    allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
-    allowColumnSorting?: boolean;
-    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
-    shouldOpenMediaViewer?: boolean;
-    allowAltTextOnImages?: boolean;
     stickyHeaders?: StickyHeaderConfig;
-    allowMediaLinking?: boolean;
     surroundTextNodesWithTextWrapper?: boolean;
-    media?: MediaOptions;
-    emojiResourceConfig?: EmojiResourceConfig;
-    smartLinks?: SmartLinksOptions;
-    extensionViewportSizes?: ExtensionViewportSize[];
-    getExtensionHeight?: GetPMNodeHeight;
-    allowCopyToClipboard?: boolean;
-    allowWrapCodeBlock?: boolean;
-    allowPlaceholderText?: boolean;
-    allowCustomPanels?: boolean;
-    allowAnnotations?: boolean;
-    allowSelectAllTrap?: boolean;
-    nodeComponents?: NodeComponentsProps;
-    allowWindowedCodeBlock?: boolean;
-    isInsideOfInlineExtension?: boolean;
     textHighlighter?: TextHighlighter;
-    allowTableAlignment?: boolean;
-    allowTableResizing?: boolean;
-    isPresentational?: boolean;
-    disableTableOverflowShadow?: boolean;
 }
 interface ParentInfo {
     parentIsIncompleteTask: boolean;

package/dist/types/react/marks/link.d.ts

@@ -2,8 +2,8 @@ import { jsx } from '@emotion/react';
 import type { LinkAttributes } from '@atlaskit/adf-schema';
 import type { MarkProps } from '../types';
 interface LinkProps extends LinkAttributes {
-    target?: string;
     isMediaLink?: boolean;
+    target?: string;
 }
 export default function Link(props: MarkProps<LinkProps>): jsx.JSX.Element;
 export {};

package/dist/types/react/nodes/blockCard.d.ts

@@ -8,13 +8,13 @@ import type { RendererAppearance } from '../../ui/Renderer/types';
 import type { SmartLinksOptions } from '../../types/smartLinksOptions';
 import type { DatasourceAttributeProperties } from '@atlaskit/adf-schema/schema';
 export default function BlockCard(props: {
-    url?: string;
     data?: object;
-    eventHandlers?: EventHandlers;
     datasource?: DatasourceAttributeProperties;
+    eventHandlers?: EventHandlers;
+    isNodeNested?: boolean;
+    layout?: string;
     portal?: HTMLElement;
     rendererAppearance?: RendererAppearance;
     smartLinks?: SmartLinksOptions;
-    layout?: string;
-    isNodeNested?: boolean;
+    url?: string;
 }): jsx.JSX.Element;

package/dist/types/react/nodes/bodiedExtension.d.ts

@@ -6,21 +6,21 @@ import type { ExtensionLayout } from '@atlaskit/adf-schema';
 import type { ExtensionHandlers } from '@atlaskit/editor-common/extensions';
 import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 interface Props {
-    serializer: Serializer<any>;
+    content?: any;
     extensionHandlers?: ExtensionHandlers;
-    rendererContext: RendererContext;
-    providers: ProviderFactory;
-    extensionType: string;
     extensionKey: string;
-    path?: PMNode[];
-    originalContent?: any;
-    parameters?: any;
-    content?: any;
+    extensionType: string;
+    extensionViewportSizes?: ExtensionViewportSize[];
     layout?: ExtensionLayout;
     localId?: string;
     marks?: PMMark[];
+    originalContent?: any;
+    parameters?: any;
+    path?: PMNode[];
+    providers: ProviderFactory;
+    rendererContext: RendererContext;
+    serializer: Serializer<any>;
     startPos: number;
-    extensionViewportSizes?: ExtensionViewportSize[];
 }
 declare const BodiedExtension: (props: React.PropsWithChildren<Props>) => React.JSX.Element;
 export default BodiedExtension;

package/dist/types/react/nodes/codeBlock/codeBlock.d.ts

@@ -1,12 +1,12 @@
 import type { WrappedComponentProps } from 'react-intl-next';
 import type { SupportedLanguages } from '@atlaskit/code';
 export interface Props {
-    text: string;
-    language: SupportedLanguages;
     allowCopyToClipboard?: boolean;
     allowWrapCodeBlock?: boolean;
-    codeBidiWarningTooltipEnabled: boolean;
     className?: string;
+    codeBidiWarningTooltipEnabled: boolean;
+    language: SupportedLanguages;
+    text: string;
 }
 declare const _default: import("react").FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps>> & {
     WrappedComponent: import("react").ComponentType<Props & WrappedComponentProps>;

package/dist/types/react/nodes/date.d.ts

@@ -2,8 +2,8 @@ import React from 'react';
 import { type WrappedComponentProps } from 'react-intl-next';
 import { type MarkDataAttributes } from '../../ui/annotations/element/useInlineAnnotationProps';
 export interface Props extends MarkDataAttributes {
-    timestamp: string;
     parentIsIncompleteTask?: boolean;
+    timestamp: string;
 }
 export declare const DateComponent: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<Props & WrappedComponentProps>;

package/dist/types/react/nodes/embedCard.d.ts

@@ -8,18 +8,18 @@ import type { EventHandlers } from '@atlaskit/editor-common/ui';
 import type { RichMediaLayout } from '@atlaskit/adf-schema';
 import type { RendererAppearance } from '../../ui/Renderer/types';
 type EmbedCardInternalProps = {
-    url?: string;
     data?: object;
     eventHandlers?: EventHandlers;
-    portal?: HTMLElement;
+    isInsideOfBlockNode?: boolean;
+    isInsideOfInlineExtension?: boolean;
+    layout: RichMediaLayout;
     originalHeight?: number;
     originalWidth?: number;
-    width?: number;
-    layout: RichMediaLayout;
+    portal?: HTMLElement;
     rendererAppearance?: RendererAppearance;
-    isInsideOfBlockNode?: boolean;
     smartLinks?: SmartLinksOptions;
-    isInsideOfInlineExtension?: boolean;
+    url?: string;
+    width?: number;
 };
 export declare const EmbedOrBlockCardInternal: ({ url, data, eventHandlers, portal, originalHeight, originalWidth, width: embedWidth, layout, rendererAppearance, isInsideOfBlockNode, smartLinks, isInsideOfInlineExtension, }: EmbedCardInternalProps) => jsx.JSX.Element;
 declare const EmbedCardWithCondition: import("react").FC<EmbedCardInternalProps>;

package/dist/types/react/nodes/emoji.d.ts

@@ -10,10 +10,10 @@ import { type MarkDataAttributes } from '../../ui/annotations/element/useInlineA
 import { type EmojiAttributes } from '@atlaskit/adf-schema';
 export interface EmojiProps extends EmojiId, EmojiAttributes, MarkDataAttributes {
     allowTextFallback?: boolean;
-    providers?: ProviderFactory;
     fitToHeight?: number;
-    showTooltip?: boolean;
+    providers?: ProviderFactory;
     resourceConfig?: EmojiResourceConfig;
+    showTooltip?: boolean;
 }
 declare function EmojiItem(props: EmojiProps): jsx.JSX.Element;
 declare namespace EmojiItem {

package/dist/types/react/nodes/extension.d.ts

@@ -7,18 +7,18 @@ import { type ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 import type { OverflowShadowProps } from '@atlaskit/editor-common/ui';
 interface Props {
     extensionHandlers?: ExtensionHandlers;
-    providers: ProviderFactory;
-    rendererContext: RendererContext;
-    extensionType: string;
     extensionKey: string;
-    path?: PMNode[];
-    text?: string;
-    parameters?: any;
+    extensionType: string;
+    extensionViewportSizes?: ExtensionViewportSize[];
     layout?: ExtensionLayout;
     localId?: string;
     marks?: PMMark[];
-    extensionViewportSizes?: ExtensionViewportSize[];
     nodeHeight?: string;
+    parameters?: any;
+    path?: PMNode[];
+    providers: ProviderFactory;
+    rendererContext: RendererContext;
+    text?: string;
 }
 type AllOrNone<T> = T | {
     [K in keyof T]?: never;

package/dist/types/react/nodes/extensionFrame.d.ts

@@ -10,18 +10,18 @@ import type { ExtensionLayout } from '@atlaskit/adf-schema';
 import type { ExtensionHandlers } from '@atlaskit/editor-common/extensions';
 import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 type Props = React.PropsWithChildren<{
-    serializer: Serializer<any>;
+    content?: any;
     extensionHandlers?: ExtensionHandlers;
-    rendererContext: RendererContext;
-    providers: ProviderFactory;
-    extensionType: string;
     extensionKey: string;
-    path?: PMNode[];
-    originalContent?: any;
-    parameters?: any;
-    content?: any;
+    extensionType: string;
     layout?: ExtensionLayout;
     localId?: string;
+    originalContent?: any;
+    parameters?: any;
+    path?: PMNode[];
+    providers: ProviderFactory;
+    rendererContext: RendererContext;
+    serializer: Serializer<any>;
 }>;
 declare const ExtensionFrame: (props: Props) => jsx.JSX.Element;
 export default ExtensionFrame;

package/dist/types/react/nodes/fallback.d.ts

@@ -3,11 +3,11 @@ type CardErrorBoundaryProps = {
     unsupportedComponent: React.ComponentType<React.PropsWithChildren<unknown>>;
 };
 export declare class CardErrorBoundary extends React.PureComponent<{
-    url?: string;
-    onClick?: (e: React.MouseEvent<HTMLElement>, url?: string) => void;
-    isDatasource?: boolean;
     children?: React.ReactNode;
     datasourceId?: string;
+    isDatasource?: boolean;
+    onClick?: (e: React.MouseEvent<HTMLElement>, url?: string) => void;
+    url?: string;
 } & CardErrorBoundaryProps> {
     state: {
         isError: boolean;

package/dist/types/react/nodes/heading-anchor.d.ts

@@ -2,11 +2,11 @@ import React from 'react';
 import type { WrappedComponentProps } from 'react-intl-next';
 export declare const HeadingAnchorWrapperClassName = "heading-anchor-wrapper";
 type Props = {
-    onCopyText: () => Promise<void>;
     enableNestedHeaderLinks?: boolean;
-    level: number;
-    hideFromScreenReader?: boolean;
     headingId?: string;
+    hideFromScreenReader?: boolean;
+    level: number;
+    onCopyText: () => Promise<void>;
 };
 type HeadingAnchorProps = Props & React.PropsWithChildren<unknown> & WrappedComponentProps;
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<HeadingAnchorProps>> & {

package/dist/types/react/nodes/heading.d.ts

@@ -4,11 +4,11 @@ import { type NodeProps } from '../types';
 import { type HeadingAnchorLinksProps } from '../../ui/Renderer/types';
 export type HeadingLevels = 1 | 2 | 3 | 4 | 5 | 6;
 declare function Heading(props: NodeProps<{
-    level: HeadingLevels;
-    headingId?: string;
-    showAnchorLink?: boolean;
     allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
-    marks?: PMNode['marks'];
+    headingId?: string;
     invisible?: boolean;
+    level: HeadingLevels;
+    marks?: PMNode['marks'];
+    showAnchorLink?: boolean;
 }>): React.JSX.Element;
 export default Heading;

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

@@ -35,41 +35,41 @@ declare const Status: React.ComponentType<import("./status").Props> & Loadable.L
 declare const Emoji: React.ComponentType<import("./emoji").EmojiProps> & Loadable.LoadableComponent;
 declare const Panel: React.ComponentType<import("./panel").Props> & Loadable.LoadableComponent;
 declare const EmbedCard: React.ComponentType<{
-    url?: string;
     data?: object;
     eventHandlers?: import("@atlaskit/editor-common/ui").EventHandlers;
-    portal?: HTMLElement;
+    isInsideOfBlockNode?: boolean;
+    isInsideOfInlineExtension?: boolean;
+    layout: import("@atlaskit/adf-schema").RichMediaLayout;
     originalHeight?: number;
     originalWidth?: number;
-    width?: number;
-    layout: import("@atlaskit/adf-schema").RichMediaLayout;
+    portal?: HTMLElement;
     rendererAppearance?: import("../../ui/Renderer/types").RendererAppearance;
-    isInsideOfBlockNode?: boolean;
     smartLinks?: import("../../types/smartLinksOptions").SmartLinksOptions;
-    isInsideOfInlineExtension?: boolean;
+    url?: string;
+    width?: number;
 }> & Loadable.LoadableComponent;
 declare const InlineCard: React.ComponentType<import("@atlaskit/editor-common/utils").Diff<import("./inlineCard").InlineCardProps & import("../../ui/SmartCardStorage").WithSmartCardStorageProps, import("../../ui/SmartCardStorage").WithSmartCardStorageProps>> & Loadable.LoadableComponent;
 declare const BlockCard: React.ComponentType<{
-    url?: string;
     data?: object;
-    eventHandlers?: import("@atlaskit/editor-common/ui").EventHandlers;
     datasource?: import("@atlaskit/adf-schema").DatasourceAttributeProperties;
+    eventHandlers?: import("@atlaskit/editor-common/ui").EventHandlers;
+    isNodeNested?: boolean;
+    layout?: string;
     portal?: HTMLElement;
     rendererAppearance?: import("../../ui/Renderer/types").RendererAppearance;
     smartLinks?: import("../../types/smartLinksOptions").SmartLinksOptions;
-    layout?: string;
-    isNodeNested?: boolean;
+    url?: string;
 }> & Loadable.LoadableComponent;
 declare const Media: React.ComponentType<React.PropsWithChildren<import("./media").MediaProps>> & Loadable.LoadableComponent;
 declare const MediaGroup: React.ComponentType<import("./mediaGroup").MediaGroupProps> & Loadable.LoadableComponent;
 declare const MediaInline: React.ComponentType<import("react-intl-next").WithIntlProps<{
-    id: string;
-    providers: import("@atlaskit/editor-common/provider-factory").ProviderFactory;
     collection?: string;
     eventHandlers?: import("@atlaskit/editor-common/ui").EventHandlers;
-    rendererAppearance?: import("../../ui/Renderer/types").RendererAppearance;
     featureFlags?: import("@atlaskit/media-common").MediaFeatureFlags;
+    id: string;
     marks?: Array<Mark>;
+    providers: import("@atlaskit/editor-common/provider-factory").ProviderFactory;
+    rendererAppearance?: import("../../ui/Renderer/types").RendererAppearance;
     ssr?: import("../..").MediaSSR;
 } & import("react-intl-next").WrappedComponentProps & import("@atlaskit/editor-common/media-inline").MediaInlineAttrs>> & Loadable.LoadableComponent;
 declare const MediaSingle: React.ComponentType<import("react-intl-next").WithIntlProps<import("./mediaSingle").Props & import("react-intl-next").WrappedComponentProps>> & Loadable.LoadableComponent;
@@ -84,19 +84,19 @@ interface ToReactFlags {
 }
 export declare const toReact: (node: Node, flags?: ToReactFlags, nodeComponents?: NodeComponentsProps) => React.ComponentType<React.PropsWithChildren<any>>;
 export interface TextWrapper {
+    content: Node[];
+    nodeSize: number;
     type: {
         name: 'textWrapper';
     };
-    content: Node[];
-    nodeSize: number;
 }
 interface NodeSimple {
+    attrs?: any;
+    nodeSize: number;
+    text?: string;
     type: {
         name: string;
     };
-    attrs?: any;
-    text?: string;
-    nodeSize: number;
 }
 export declare const mergeTextNodes: (nodes: (Node | NodeSimple)[]) => (Node | TextWrapper | NodeSimple)[];
 export declare const isText: (type: string) => type is "text";

package/dist/types/react/nodes/inlineCard.d.ts

@@ -5,13 +5,13 @@ import type { SmartLinksOptions } from '../../types/smartLinksOptions';
 import { type MarkDataAttributes } from '../../ui/annotations/element/useInlineAnnotationProps';
 import type { RendererAppearance } from '../../ui/Renderer/types';
 export interface InlineCardProps extends MarkDataAttributes {
-    url?: string;
     data?: object;
     eventHandlers?: EventHandlers;
-    portal?: HTMLElement;
-    smartLinks?: SmartLinksOptions;
     marks?: Mark[];
+    portal?: HTMLElement;
     rendererAppearance?: RendererAppearance;
+    smartLinks?: SmartLinksOptions;
+    url?: string;
 }
 declare const _default: {
     new (props: import("@atlaskit/editor-common/utils").Diff<InlineCardProps & WithSmartCardStorageProps, WithSmartCardStorageProps> | Readonly<import("@atlaskit/editor-common/utils").Diff<InlineCardProps & WithSmartCardStorageProps, WithSmartCardStorageProps>>): {