@atlaskit/renderer 120.5.1 → 120.5.3

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atlaskit/renderer
 
+## 120.5.3
+
+### Patch Changes
+
+- [`2dbce9ef92219`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/2dbce9ef92219) -
+  Added a jira specific featuer flag to SSR the EmbedCard and BlockCard.
+- Updated dependencies
+
+## 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

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/blockCard.js

@@ -127,7 +127,7 @@ function BlockCard(props) {
     });
   }
   var cardComponent;
-  if (smartLinks !== null && smartLinks !== void 0 && smartLinks.ssr && url && (0, _platformFeatureFlags.fg)('platform_ssr_smartlink_cards')) {
+  if (smartLinks !== null && smartLinks !== void 0 && smartLinks.ssr && url && ((0, _platformFeatureFlags.fg)('platform_ssr_smartlink_cards') || (0, _platformFeatureFlags.fg)('jfp-magma-ssr-iv-editor-links'))) {
     cardComponent = (0, _react.jsx)(_ssr.CardSSR, (0, _extends2.default)({
       appearance: "block",
       platform: platform

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

@@ -156,7 +156,7 @@ function EmbedCardInternal(props) {
       }
     };
     var cardComponent;
-    if (smartLinks !== null && smartLinks !== void 0 && smartLinks.ssr && url && (0, _platformFeatureFlags.fg)('platform_ssr_smartlink_embeds')) {
+    if (smartLinks !== null && smartLinks !== void 0 && smartLinks.ssr && url && ((0, _platformFeatureFlags.fg)('platform_ssr_smartlink_embeds') || (0, _platformFeatureFlags.fg)('jfp-magma-ssr-iv-editor-links'))) {
       var _smartLinks$frameStyl2;
       var ssrCardProps = {
         url: url,

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.5.0";
+var packageVersion = "120.5.2";
 var setAsQueryContainerStyles = (0, _react2.css)({
   containerName: 'ak-renderer-wrapper',
   containerType: 'inline-size'

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

@@ -114,7 +114,7 @@ export default function BlockCard(props) {
     });
   }
   let cardComponent;
-  if (smartLinks !== null && smartLinks !== void 0 && smartLinks.ssr && url && fg('platform_ssr_smartlink_cards')) {
+  if (smartLinks !== null && smartLinks !== void 0 && smartLinks.ssr && url && (fg('platform_ssr_smartlink_cards') || fg('jfp-magma-ssr-iv-editor-links'))) {
     cardComponent = jsx(CardSSR, _extends({
       appearance: "block",
       platform: platform

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

@@ -144,7 +144,7 @@ function EmbedCardInternal(props) {
       }
     };
     let cardComponent;
-    if (smartLinks !== null && smartLinks !== void 0 && smartLinks.ssr && url && fg('platform_ssr_smartlink_embeds')) {
+    if (smartLinks !== null && smartLinks !== void 0 && smartLinks.ssr && url && (fg('platform_ssr_smartlink_embeds') || fg('jfp-magma-ssr-iv-editor-links'))) {
       var _smartLinks$frameStyl2;
       const ssrCardProps = {
         url,

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.5.0";
+const packageVersion = "120.5.2";
 const setAsQueryContainerStyles = css({
   containerName: 'ak-renderer-wrapper',
   containerType: 'inline-size'

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

@@ -119,7 +119,7 @@ export default function BlockCard(props) {
     });
   }
   var cardComponent;
-  if (smartLinks !== null && smartLinks !== void 0 && smartLinks.ssr && url && fg('platform_ssr_smartlink_cards')) {
+  if (smartLinks !== null && smartLinks !== void 0 && smartLinks.ssr && url && (fg('platform_ssr_smartlink_cards') || fg('jfp-magma-ssr-iv-editor-links'))) {
     cardComponent = jsx(CardSSR, _extends({
       appearance: "block",
       platform: platform

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

@@ -148,7 +148,7 @@ function EmbedCardInternal(props) {
       }
     };
     var cardComponent;
-    if (smartLinks !== null && smartLinks !== void 0 && smartLinks.ssr && url && fg('platform_ssr_smartlink_embeds')) {
+    if (smartLinks !== null && smartLinks !== void 0 && smartLinks.ssr && url && (fg('platform_ssr_smartlink_embeds') || fg('jfp-magma-ssr-iv-editor-links'))) {
       var _smartLinks$frameStyl2;
       var ssrCardProps = {
         url: url,

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.5.0";
+var packageVersion = "120.5.2";
 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;