@atlaskit/editor-common 107.28.2 → 107.29.0

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

@@ -4,8 +4,8 @@
  */
 import { jsx } from '@emotion/react';
 export type LegacyContentHeaderProps = {
-    isNodeSelected?: boolean;
     isNodeHovered?: boolean;
+    isNodeSelected?: boolean;
     onMouseEnter?: () => void;
     onMouseLeave?: () => void;
 };

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

@@ -5,11 +5,11 @@
 import type { CSSProperties } from 'react';
 import { jsx } from '@emotion/react';
 type EditToggleProps = {
-    isNodeHovered?: boolean;
     customContainerStyles?: CSSProperties;
+    isNodeHovered?: boolean;
     setIsNodeHovered?: (isNodeHovered: boolean) => void;
-    showBodiedExtensionRendererView?: boolean;
     setShowBodiedExtensionRendererView?: (showBodiedExtensionRendererView: boolean) => void;
+    showBodiedExtensionRendererView?: boolean;
 };
 export declare const EditToggle: ({ isNodeHovered, customContainerStyles, setIsNodeHovered, showBodiedExtensionRendererView, setShowBodiedExtensionRendererView, }: EditToggleProps) => jsx.JSX.Element;
 export {};

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

@@ -7,17 +7,17 @@ import { jsx } from '@emotion/react';
 import { type ExtensionsPluginInjectionAPI } from '../../types';
 export declare const getShouldShowBodiedMacroLabel: (isBodiedMacro: boolean | undefined, isNodeHovered: boolean | undefined, showLivePagesBodiedMacrosRendererView: boolean | undefined, showBodiedExtensionRendererView: boolean | undefined, showUpdatedLivePages1PBodiedExtensionUI: boolean | undefined) => boolean | undefined;
 type ExtensionLabelProps = {
-    text: string;
+    customContainerStyles?: CSSProperties;
     extensionName: string;
+    isBodiedMacro?: boolean;
     isNodeHovered?: boolean;
     isNodeNested?: boolean;
-    customContainerStyles?: CSSProperties;
+    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
     setIsNodeHovered?: (isHovered: boolean) => void;
-    isBodiedMacro?: boolean;
-    showUpdatedLivePages1PBodiedExtensionUI?: boolean;
-    showLivePagesBodiedMacrosRendererView?: boolean;
     showBodiedExtensionRendererView?: boolean;
-    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
+    showLivePagesBodiedMacrosRendererView?: boolean;
+    showUpdatedLivePages1PBodiedExtensionUI?: boolean;
+    text: string;
 };
 export declare const ExtensionLabel: ({ text, extensionName, isNodeHovered, customContainerStyles, isNodeNested, setIsNodeHovered, isBodiedMacro, showUpdatedLivePages1PBodiedExtensionUI, showLivePagesBodiedMacrosRendererView, showBodiedExtensionRendererView, pluginInjectionApi, }: ExtensionLabelProps) => jsx.JSX.Element;
 export {};

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

@@ -4,23 +4,23 @@ import { type ExtensionsPluginInjectionAPI } from '../../types';
 import type { LozengeData } from './index';
 export declare const ICON_SIZE = 24;
 type LozengeComponentProps = {
-    lozengeData?: LozengeData;
-    extensionName: string;
-    title: string;
-    params: any;
-    renderImage: (lozengeData: LozengeData) => void;
-    isNodeSelected?: boolean;
-    showMacroInteractionDesignUpdates?: boolean;
     customContainerStyles?: CSSProperties;
+    extensionName: string;
+    isBodiedMacro?: boolean;
     isNodeHovered?: boolean;
     isNodeNested?: boolean;
+    isNodeSelected?: boolean;
+    lozengeData?: LozengeData;
+    params: any;
+    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
+    renderImage: (lozengeData: LozengeData) => void;
     setIsNodeHovered?: (isHovered: boolean) => void;
-    isBodiedMacro?: boolean;
+    setShowBodiedExtensionRendererView?: (showBodiedExtensionRendererView: boolean) => void;
+    showBodiedExtensionRendererView?: boolean;
     showLivePagesBodiedMacrosRendererView?: boolean;
+    showMacroInteractionDesignUpdates?: boolean;
     showUpdatedLivePages1PBodiedExtensionUI?: boolean;
-    showBodiedExtensionRendererView?: boolean;
-    setShowBodiedExtensionRendererView?: (showBodiedExtensionRendererView: boolean) => void;
-    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
+    title: string;
 };
 export declare const LozengeComponent: ({ lozengeData, extensionName, title, params, renderImage, showMacroInteractionDesignUpdates, customContainerStyles, isNodeHovered, isNodeNested, setIsNodeHovered, isBodiedMacro, showLivePagesBodiedMacrosRendererView, showUpdatedLivePages1PBodiedExtensionUI, showBodiedExtensionRendererView, setShowBodiedExtensionRendererView, pluginInjectionApi, }: LozengeComponentProps) => jsx.JSX.Element;
 export {};

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

@@ -8,23 +8,23 @@ import { jsx } from '@emotion/react';
 import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
 import { type ExtensionsPluginInjectionAPI } from '../../types';
 export interface Props {
-    node: PmNode;
-    showMacroInteractionDesignUpdates?: boolean;
-    isNodeSelected?: boolean;
+    customContainerStyles?: CSSProperties;
+    isBodiedMacro?: boolean;
     isNodeHovered?: boolean;
     isNodeNested?: boolean;
-    customContainerStyles?: CSSProperties;
+    isNodeSelected?: boolean;
+    node: PmNode;
+    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
     setIsNodeHovered?: (isHovered: boolean) => void;
-    isBodiedMacro?: boolean;
+    setShowBodiedExtensionRendererView?: (showBodiedExtensionRendererView: boolean) => void;
+    showBodiedExtensionRendererView?: boolean;
     showLivePagesBodiedMacrosRendererView?: boolean;
+    showMacroInteractionDesignUpdates?: boolean;
     showUpdatedLivePages1PBodiedExtensionUI?: boolean;
-    showBodiedExtensionRendererView?: boolean;
-    setShowBodiedExtensionRendererView?: (showBodiedExtensionRendererView: boolean) => void;
-    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
 }
 export interface LozengeData {
-    url: string;
     height?: number;
+    url: string;
     width?: number;
 }
 export default class ExtensionLozenge extends Component<Props, any> {

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

@@ -9,20 +9,20 @@ import type { ProsemirrorGetPosHandler } from '../react-node-view';
 import type { EditorAppearance } from '../types';
 import type { ExtensionsPluginInjectionAPI, MacroInteractionDesignFeatureFlags } from './types';
 export interface Props {
+    editorAppearance?: EditorAppearance;
     editorView: EditorView;
-    node: PMNode;
+    eventDispatcher?: EventDispatcher;
+    extensionHandlers: ExtensionHandlers;
     getPos: ProsemirrorGetPosHandler;
-    providerFactory?: ProviderFactory;
     handleContentDOMRef: (node: HTMLElement | null) => void;
-    extensionHandlers: ExtensionHandlers;
-    references?: ReferenceEntity[];
-    editorAppearance?: EditorAppearance;
-    pluginInjectionApi: ExtensionsPluginInjectionAPI;
-    eventDispatcher?: EventDispatcher;
     macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
+    node: PMNode;
+    pluginInjectionApi: ExtensionsPluginInjectionAPI;
+    providerFactory?: ProviderFactory;
+    references?: ReferenceEntity[];
+    rendererExtensionHandlers?: ExtensionHandlers;
     showLivePagesBodiedMacrosRendererView?: (node: ADFEntity) => boolean;
     showUpdatedLivePages1PBodiedExtensionUI?: (node: ADFEntity) => boolean;
-    rendererExtensionHandlers?: ExtensionHandlers;
 }
 export declare class Extension extends Component<Props, any> {
     static displayName: string;

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

@@ -8,37 +8,37 @@ import type { ProsemirrorGetPosHandler } from '../react-node-view';
 import type { EditorAppearance } from '../types';
 import type { ExtensionsPluginInjectionAPI, MacroInteractionDesignFeatureFlags } from './types';
 export interface Props {
+    editorAppearance?: EditorAppearance;
     editorView: EditorView;
-    node: PMNode;
-    getPos: ProsemirrorGetPosHandler;
-    handleContentDOMRef: (node: HTMLElement | null) => void;
+    eventDispatcher?: EventDispatcher;
     extensionHandlers: ExtensionHandlers;
     extensionProvider?: Promise<ExtensionProvider>;
-    references?: ReferenceEntity[];
-    editorAppearance?: EditorAppearance;
-    pluginInjectionApi: ExtensionsPluginInjectionAPI;
-    eventDispatcher?: EventDispatcher;
+    getPos: ProsemirrorGetPosHandler;
+    handleContentDOMRef: (node: HTMLElement | null) => void;
+    isLivePageViewMode?: boolean;
     macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
+    node: PMNode;
+    pluginInjectionApi: ExtensionsPluginInjectionAPI;
+    references?: ReferenceEntity[];
+    rendererExtensionHandlers?: ExtensionHandlers;
     showLivePagesBodiedMacrosRendererView?: (node: ADFEntity) => boolean;
     showUpdatedLivePages1PBodiedExtensionUI?: (node: ADFEntity) => boolean;
-    rendererExtensionHandlers?: ExtensionHandlers;
-    isLivePageViewMode?: boolean;
 }
 export interface State {
-    extensionProvider?: ExtensionProvider;
-    extensionHandlersFromProvider?: ExtensionHandlers;
     _privateProps?: {
-        __hideFrame?: boolean;
         __allowBodiedOverride?: boolean;
+        __hideFrame?: boolean;
     };
     activeChildIndex?: number;
+    extensionHandlersFromProvider?: ExtensionHandlers;
+    extensionProvider?: ExtensionProvider;
     isNodeHovered?: boolean;
     showBodiedExtensionRendererView?: boolean;
 }
 export type PropsNew = Omit<Props, 'extensionProvider'> & {
     extensionProvider?: ExtensionProvider;
-    showBodiedExtensionRendererView?: boolean;
     setShowBodiedExtensionRendererView?: (showBodiedExtensionRendererView: boolean) => void;
+    showBodiedExtensionRendererView?: boolean;
 };
 export type StateNew = Omit<State, 'extensionProvider' | 'showBodiedExtensionRendererView'>;
 export declare const ExtensionComponent: (props: Props) => React.JSX.Element;

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

@@ -8,8 +8,8 @@ import { jsx } from '@emotion/react';
 import type { MacroInteractionDesignFeatureFlags } from './types';
 type Props = {
     children: React.ReactNode;
-    nodeType: string;
     macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
+    nodeType: string;
 };
 /**
  * If inlineExtension, add zero width space to the end of the nodes and wrap with span;

package/dist/types/extensibility/MultiBodiedExtension/action-api.d.ts

@@ -4,13 +4,13 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { EventDispatcher } from '../../event-dispatcher';
 import type { MultiBodiedExtensionActions } from '../../extensions';
 type ActionsProps = {
-    updateActiveChild: (index: number) => boolean;
-    node: PmNode;
-    editorView: EditorView;
-    getPos: () => number | undefined;
-    eventDispatcher?: EventDispatcher;
     allowBodiedOverride: boolean;
     childrenContainer: React.ReactNode;
+    editorView: EditorView;
+    eventDispatcher?: EventDispatcher;
+    getPos: () => number | undefined;
+    node: PmNode;
+    updateActiveChild: (index: number) => boolean;
 };
 export declare const useMultiBodiedExtensionActions: ({ updateActiveChild, editorView, getPos, node, eventDispatcher, allowBodiedOverride, childrenContainer, }: ActionsProps) => MultiBodiedExtensionActions;
 export {};

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

@@ -13,21 +13,21 @@ import type { OverflowShadowProps } from '../../ui';
 import type { ExtensionsPluginInjectionAPI, MacroInteractionDesignFeatureFlags } from '../types';
 export type TryExtensionHandlerType = (actions: MultiBodiedExtensionActions | undefined) => React.ReactElement | null;
 type Props = {
-    node: PmNode;
-    handleContentDOMRef: (node: HTMLElement | null) => void;
+    allowBodiedOverride?: boolean;
+    editorAppearance?: EditorAppearance;
     editorView: EditorView;
-    getPos: () => number | undefined;
-    tryExtensionHandler: TryExtensionHandlerType;
     eventDispatcher?: EventDispatcher;
-    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
-    editorAppearance?: EditorAppearance;
-    macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
-    isNodeSelected?: boolean;
+    getPos: () => number | undefined;
+    handleContentDOMRef: (node: HTMLElement | null) => void;
+    isLivePageViewMode?: boolean;
     isNodeHovered?: boolean;
     isNodeNested?: boolean;
+    isNodeSelected?: boolean;
+    macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
+    node: PmNode;
+    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
     setIsNodeHovered?: (isHovered: boolean) => void;
-    isLivePageViewMode?: boolean;
-    allowBodiedOverride?: boolean;
+    tryExtensionHandler: TryExtensionHandlerType;
 };
 declare const MultiBodiedExtension: (props: Props & OverflowShadowProps) => jsx.JSX.Element;
 export default MultiBodiedExtension;

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

@@ -15,19 +15,19 @@ interface ExtensionNodeViewOptions {
     getExtensionHeight?: GetPMNodeHeight;
 }
 interface ReactExtensionNodeProps {
-    extensionNodeViewOptions?: ExtensionNodeViewOptions;
-    providerFactory: ProviderFactory;
     extensionHandlers: ExtensionHandlers;
-    pluginInjectionApi: ExtensionsPluginInjectionAPI;
+    extensionNodeViewOptions?: ExtensionNodeViewOptions;
     macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
+    pluginInjectionApi: ExtensionsPluginInjectionAPI;
+    providerFactory: ProviderFactory;
+    rendererExtensionHandlers?: ExtensionHandlers;
     showLivePagesBodiedMacrosRendererView?: (node: ADFEntity) => boolean;
     showUpdatedLivePages1PBodiedExtensionUI?: (node: ADFEntity) => boolean;
-    rendererExtensionHandlers?: ExtensionHandlers;
 }
 export declare class ExtensionNode<AdditionalParams = unknown> extends ReactNodeView<ReactExtensionNodeProps & AdditionalParams> {
     ignoreMutation(mutation: MutationRecord | {
-        type: 'selection';
         target: Node;
+        type: 'selection';
     }): boolean;
     createDomRef(): HTMLElement;
     /**
@@ -45,14 +45,14 @@ export declare class ExtensionNode<AdditionalParams = unknown> extends ReactNode
         dom: HTMLDivElement;
     } | undefined;
     render(props: {
-        providerFactory: ProviderFactory;
         extensionHandlers: ExtensionHandlers;
         extensionNodeViewOptions?: ExtensionNodeViewOptions;
-        pluginInjectionApi: ExtensionsPluginInjectionAPI;
         macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
+        pluginInjectionApi: ExtensionsPluginInjectionAPI;
+        providerFactory: ProviderFactory;
+        rendererExtensionHandlers?: ExtensionHandlers;
         showLivePagesBodiedMacrosRendererView?: (node: ADFEntity) => boolean;
         showUpdatedLivePages1PBodiedExtensionUI?: (node: ADFEntity) => boolean;
-        rendererExtensionHandlers?: ExtensionHandlers;
     }, forwardRef: ForwardRef): React.JSX.Element;
 }
 export default function ExtensionNodeView(portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory, extensionHandlers: ExtensionHandlers, extensionNodeViewOptions: ExtensionNodeViewOptions, pluginInjectionApi: ExtensionsPluginInjectionAPI, macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags, showLivePagesBodiedMacrosRendererView?: (node: ADFEntity) => boolean, showUpdatedLivePages1PBodiedExtensionUI?: (node: ADFEntity) => boolean, rendererExtensionHandlers?: ExtensionHandlers): (node: PmNode, view: EditorView, getPos: getPosHandler) => NodeView;

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

@@ -13,7 +13,7 @@ export declare function getExtensionModuleNodePrivateProps(extensionProvider: Ex
     [prop: string]: any;
 }>;
 export declare function getNodeRenderer<T extends Parameters>(extensionProvider: ExtensionProvider, extensionType: ExtensionType, extensionKey: ExtensionKey): React.ComponentType<{
+    actions?: MultiBodiedExtensionActions;
     node: ExtensionParams<T>;
     references?: ReferenceEntity[];
-    actions?: MultiBodiedExtensionActions;
 }> & Loadable.LoadableComponent;

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

@@ -2,14 +2,14 @@ import type { ADFEntity } from '@atlaskit/adf-utils/types';
 import type { NodeWithPos } from '@atlaskit/editor-prosemirror/utils';
 import type { Parameters } from './extension-parameters';
 export interface ExtensionParams<T extends Parameters> {
+    content?: object | string;
     extensionKey: string;
     extensionType: string;
-    type?: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
-    parameters?: T;
-    content?: object | string;
-    localId?: string;
     fragmentLocalId?: string;
     layout?: string;
+    localId?: string;
+    parameters?: T;
+    type?: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
 }
 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;
@@ -17,13 +17,11 @@ export type OnSaveCallbackAsync<T extends Parameters = Parameters> = (params: T)
 export type TransformBefore<T extends Parameters = Parameters> = (data: T) => any;
 export type TransformAfter<T extends Parameters = Parameters> = (data: any) => Promise<Partial<T>>;
 export type ExtensionAPI<T extends Parameters = Parameters> = {
-    editInContextPanel: (transformBefore: TransformBefore<T>, transformAfter: TransformAfter<T>) => void;
     _editInLegacyMacroBrowser: () => void;
-    getNodeWithPosByLocalId: (localId: string) => NodeWithPos;
     doc: {
         insertAfter: (localId: string, adf: ADFEntity, options?: {
-            allowSelectionToNewNode?: boolean;
             allowSelectionNearNewNode?: boolean;
+            allowSelectionToNewNode?: boolean;
         }) => void;
         scrollTo: (localId: string) => void;
         update: (localId: string, mutationCallback: (currentValue: Pick<ADFEntity, 'content' | 'attrs' | 'marks'>) => Pick<ADFEntity, 'content' | 'attrs' | 'marks'>, options?: {
@@ -31,6 +29,8 @@ export type ExtensionAPI<T extends Parameters = Parameters> = {
             scrollIntoView?: boolean;
         }) => void;
     };
+    editInContextPanel: (transformBefore: TransformBefore<T>, transformAfter: TransformAfter<T>) => void;
+    getNodeWithPosByLocalId: (localId: string) => NodeWithPos;
 };
 export type UpdateExtension<T extends Parameters = Parameters> = (extensionParameters: T, actions?: ExtensionAPI<T>) => Promise<T | void>;
 export interface Extension<T extends Parameters = Parameters> {
@@ -44,13 +44,13 @@ export type ReferenceEntity = {
     [prop: string]: ADFEntity | Object;
 };
 export type MultiBodiedExtensionActions = {
-    changeActive: (index: number) => boolean;
     addChild: () => boolean;
+    changeActive: (index: number) => boolean;
+    getChildren(): Array<ADFEntity>;
+    getChildrenContainer(): React.ReactNode;
     getChildrenCount: () => number;
     removeChild: (index: number) => boolean;
     updateParameters: (parameters: Parameters) => boolean;
-    getChildren(): Array<ADFEntity>;
-    getChildrenContainer(): React.ReactNode;
 };
 export type ParametersGetter<T extends Parameters = Parameters> = TransformBefore<T>;
 export type AsyncParametersGetter<T extends Parameters = Parameters> = TransformAfter<T>;

package/dist/types/extensions/types/extension-manifest-toolbar-item.d.ts

@@ -4,10 +4,13 @@ import type { ExtensionAPI } from './extension-handler';
 import type { ExtensionIconModule } from './extension-manifest-common';
 export type ToolbarButtonAction = (contextNode: ADFEntity, api: ExtensionAPI) => Promise<void>;
 export type ToolbarButton = ExtensionModuleToolbarButtonLabelOrIcon & {
-    key: string;
     action: ToolbarButtonAction;
-    label: string;
     ariaLabel?: string;
+    disabled?: boolean;
+    display?: 'icon' | 'label' | 'icon-and-label';
+    icon?: () => ExtensionIconModule;
+    key: string;
+    label: string;
     tooltip?: React.ReactNode | string;
     /**
      * Tooltip Style
@@ -15,9 +18,6 @@ export type ToolbarButton = ExtensionModuleToolbarButtonLabelOrIcon & {
      * How to use: https://atlassian.design/components/tooltip/examples#custom-component
      */
     tooltipStyle?: React.ForwardRefExoticComponent<any> | React.ComponentType<any>;
-    icon?: () => ExtensionIconModule;
-    display?: 'icon' | 'label' | 'icon-and-label';
-    disabled?: boolean;
 };
 export type ToolbarItem = ToolbarButton | FloatingToolbarItem<Command>;
 export type ToolbarContext = ExtensionNodeContext | StandardNodeContext;
@@ -27,28 +27,31 @@ export type ContextualToolbar = {
 };
 export type ExtensionModuleToolbarButtonLabelOrIcon = ExtensionModuleToolbarButtonWithIcon | ExtensionModuleToolbarButtonWithLabel;
 export type ExtensionModuleToolbarButtonWithIcon = {
-    icon: () => ExtensionIconModule;
     display?: 'icon' | 'icon-and-label';
+    icon: () => ExtensionIconModule;
 };
 export type ExtensionModuleToolbarButtonWithLabel = {
     display?: 'label';
 };
 export type ExtensionNodeContext = {
-    type: 'extension';
-    nodeType: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
     extensionKey: string | string[];
     extensionType?: string;
+    nodeType: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
     shouldExclude?: (node: ADFEntity) => boolean;
+    type: 'extension';
 };
 export type StandardNodeContext = {
-    type: 'node';
     nodeType: 'table';
+    type: 'node';
 };
 export type ExtensionToolbarItem = ExtensionToolbarButton | FloatingToolbarDropdown<Command>;
 export type ExtensionToolbarButton = {
+    action: ToolbarButtonAction;
+    ariaLabel?: string;
+    disabled?: boolean;
+    icon?: () => ExtensionIconModule;
     key: string;
     label?: string;
-    ariaLabel?: string;
     tooltip?: React.ReactNode | string;
     /**
      * Tooltip Style
@@ -56,7 +59,4 @@ export type ExtensionToolbarButton = {
      * How to use: https://atlassian.design/components/tooltip/examples#custom-component
      */
     tooltipStyle?: React.ForwardRefExoticComponent<any> | React.ComponentType<any>;
-    icon?: () => ExtensionIconModule;
-    action: ToolbarButtonAction;
-    disabled?: boolean;
 };

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

@@ -9,9 +9,9 @@ export type ExtensionType = string;
 export type ExtensionKey = string;
 export type ExtensionModuleKey = string;
 export type ExtensionComponentProps<T extends Parameters = Parameters> = {
-    node: ExtensionParams<T>;
-    actions?: MultiBodiedExtensionActions;
     [key: string]: any;
+    actions?: MultiBodiedExtensionActions;
+    node: ExtensionParams<T>;
 };
 export type ExtensionComponent<T extends Parameters> = ComponentType<React.PropsWithChildren<ExtensionComponentProps<T>>>;
 export type ExtensionComponentModule<T extends Parameters> = Promise<MaybeESModule<ExtensionComponent<T>>>;
@@ -19,30 +19,30 @@ export type Serializer<T extends Parameters = Parameters> = (data: T) => string;
 export type Deserializer<T extends Parameters = Parameters> = (value: string) => T;
 export type ExtensionModuleActionObject<T extends Parameters = Parameters> = {
     key: ExtensionModuleKey;
-    type: 'node';
     parameters?: T;
+    type: 'node';
 };
 export type MaybeADFEntity = MaybeESModule<ADFEntity | Array<ADFEntity> | void>;
 export type ExtensionModuleActionHandler = (extensionAPI: ExtensionAPI) => Promise<MaybeADFEntity>;
 export type ExtensionModuleAction<T extends Parameters = Parameters> = ExtensionModuleActionObject<T> | ExtensionModuleActionHandler;
 export type ExtensionModule<T extends Parameters = Parameters> = {
-    key: string;
-    title?: string;
+    action: ExtensionModuleAction<T>;
+    categories?: string[];
     description?: string;
-    icon?: () => ExtensionIconModule;
-    priority?: number;
     featured?: boolean;
+    icon?: () => ExtensionIconModule;
+    key: string;
     keywords?: string[];
-    categories?: string[];
-    action: ExtensionModuleAction<T>;
     parameters?: T;
+    priority?: number;
+    title?: string;
 };
 export type DynamicFieldDefinitions<T> = (parameters: T) => FieldDefinition[];
 export type ExtensionModuleNode<T extends Parameters = Parameters> = {
-    type: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
+    getFieldsDefinition?: (extensionParameters: T) => Promise<FieldDefinition[] | DynamicFieldDefinitions<T>>;
     render: () => ExtensionComponentModule<T>;
+    type: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
     update?: UpdateExtension<T>;
-    getFieldsDefinition?: (extensionParameters: T) => Promise<FieldDefinition[] | DynamicFieldDefinitions<T>>;
 };
 export type PreloadableExtensionModuleNode<T extends Parameters = Parameters> = ExtensionModuleNode<T> & {
     preloadRender: () => Promise<void>;
@@ -64,8 +64,8 @@ export type ExtensionModuleFieldTypeUser = {
     provider: UserFieldContextProvider;
 };
 export type ExtensionModuleFieldTypeFieldset<T extends Parameters = Parameters> = {
-    serializer?: Serializer<T>;
     deserializer?: Deserializer<T>;
+    serializer?: Serializer<T>;
 };
 export type ExtensionModuleFields<T extends Parameters = Parameters> = {
     custom?: {
@@ -79,11 +79,11 @@ export type ExtensionModuleFields<T extends Parameters = Parameters> = {
     };
 };
 export type ExtensionModules<T extends Parameters = Parameters> = {
-    quickInsert?: ExtensionModule<T>[];
-    nodes?: ExtensionModuleNodes<T>;
-    fields?: ExtensionModuleFields<T>;
     autoConvert?: ExtensionModuleAutoConvert;
     contextualToolbars?: ContextualToolbar[];
+    fields?: ExtensionModuleFields<T>;
+    nodes?: ExtensionModuleNodes<T>;
+    quickInsert?: ExtensionModule<T>[];
 };
 export type ExtensionQuickInsertModule = 'quickInsert';
 export type ExtensionModuleType<T extends Parameters = Parameters> = Exclude<keyof ExtensionModules<T>, 'nodes' | 'fields'>;
@@ -95,23 +95,23 @@ export type ExtensionDeprecationStatus = {
     message?: string | React.ReactNode;
 };
 export type ExtensionManifest<T extends Parameters = Parameters> = {
-    type: ExtensionType;
-    key: ExtensionKey;
-    title: string;
-    description?: string;
-    summary?: string;
-    deprecation?: ExtensionDeprecationStatus;
+    autoConvert?: {
+        matchers: Array<AutoConvertMatches>;
+    };
     categories?: string[];
-    keywords?: string[];
+    deprecation?: ExtensionDeprecationStatus;
+    description?: string;
     documentationUrl?: string;
     icons: {
-        '48': () => ExtensionIconModule;
         [dimensions: string]: () => ExtensionIconModule;
+        '48': () => ExtensionIconModule;
     };
+    key: ExtensionKey;
+    keywords?: string[];
     modules: ExtensionModules<T>;
-    autoConvert?: {
-        matchers: Array<AutoConvertMatches>;
-    };
+    summary?: string;
+    title: string;
+    type: ExtensionType;
 };
 export type Icon = () => ExtensionIconModule;
 export type Module<T extends Parameters> = MaybeESModule<T>;

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

@@ -1,10 +1,10 @@
 import { type ExtensionAutoConvertHandler, type ExtensionKey, type ExtensionManifest, type ExtensionType } from './extension-manifest';
 import { type Parameters } from './extension-parameters';
 export interface ExtensionProvider<T extends Parameters = any> {
+    getAutoConverter(): Promise<ExtensionAutoConvertHandler[]>;
+    getExtension(type: ExtensionType, key: ExtensionKey): Promise<ExtensionManifest<T> | undefined>;
     getExtensions(): Promise<ExtensionManifest<T>[]>;
-    preload?(): Promise<void>;
     getPreloadedExtension?(type: ExtensionType, key: ExtensionKey): ExtensionManifest<T> | undefined;
-    getExtension(type: ExtensionType, key: ExtensionKey): Promise<ExtensionManifest<T> | undefined>;
+    preload?(): Promise<void>;
     search(keyword: string): Promise<ExtensionManifest<T>[]>;
-    getAutoConverter(): Promise<ExtensionAutoConvertHandler[]>;
 }