@atlaskit/renderer 120.5.0 → 120.5.2

package/dist/types-ts4.5/react/types.d.ts

@@ -8,66 +8,66 @@ import type { Serializer } from '../serializer';
 import type { RendererAppearance, HeadingAnchorLinksProps } from '../ui/Renderer/types';
 import type { AnnotationId, AnnotationTypes } from '@atlaskit/adf-schema';
 export interface RendererContext {
-    objectAri?: string;
-    containerAri?: string;
     adDoc?: any;
+    containerAri?: string;
+    objectAri?: string;
     schema?: Schema;
 }
 export interface NodeMeta {
-    text?: PMNode['text'];
-    providers?: ProviderFactory | undefined;
-    eventHandlers?: EventHandlers | undefined;
-    extensionHandlers?: ExtensionHandlers | undefined;
-    portal?: HTMLElement | undefined;
-    rendererContext?: RendererContext;
-    serializer: Serializer<JSX.Element>;
+    [key: string]: any;
+    allowCopyToClipboard?: boolean;
+    allowCustomPanels?: boolean;
+    allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
+    allowPlaceholderText?: boolean;
+    allowWrapCodeBlock?: boolean;
     content?: {
         [key: string]: any;
     } | null;
-    allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
-    allowCopyToClipboard?: boolean;
-    allowWrapCodeBlock?: boolean;
-    allowPlaceholderText?: boolean;
-    allowCustomPanels?: boolean;
-    rendererAppearance?: RendererAppearance;
-    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
-    nodeType: NodeType['name'];
-    marks: PMNode['marks'];
     dataAttributes: {
         'data-renderer-start-pos': number;
     };
-    [key: string]: any;
+    eventHandlers?: EventHandlers | undefined;
+    extensionHandlers?: ExtensionHandlers | undefined;
+    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
+    marks: PMNode['marks'];
+    nodeType: NodeType['name'];
+    portal?: HTMLElement | undefined;
+    providers?: ProviderFactory | undefined;
+    rendererAppearance?: RendererAppearance;
+    rendererContext?: RendererContext;
+    serializer: Serializer<JSX.Element>;
+    text?: PMNode['text'];
 }
 export interface MarkMeta {
+    [key: string]: any;
     dataAttributes: {
-        'data-renderer-mark': true;
         'data-block-mark'?: true;
+        'data-renderer-mark': true;
     };
     eventHandlers?: EventHandlers;
     fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
-    markKey?: any;
     isInline?: boolean;
-    [key: string]: any;
+    markKey?: any;
 }
 export interface AnnotationMarkMeta extends MarkMeta {
-    id: AnnotationId;
-    annotationType: AnnotationTypes;
-    annotationParentIds: string[];
     allowAnnotations: boolean;
-    useBlockLevel?: boolean;
+    annotationParentIds: string[];
+    annotationType: AnnotationTypes;
+    id: AnnotationId;
     isMediaInline?: boolean;
+    useBlockLevel?: boolean;
 }
 export type NodeProps<NodeAttrs = Object> = NodeAttrs & PropsWithChildren<NodeMeta>;
 export type MarkProps<MarkAttrs = Object> = MarkAttrs & PropsWithChildren<MarkMeta>;
 export type TextHighlighter = {
-    pattern: RegExp;
     component: React.ComponentType<{
         children: React.ReactNode;
-        match: string;
-        marks: Set<string>;
         groups: Array<string> | undefined;
+        marks: Set<string>;
+        match: string;
         startPos: number;
     }>;
+    pattern: RegExp;
 };
 export interface ExtensionViewportSize {
     extensionId?: string;

package/dist/types-ts4.5/react/utils/segment-text.d.ts

@@ -1,10 +1,10 @@
 import type { TextHighlighter } from '../types';
 export type TextSegment = {
-    type: 'plain';
     text: string;
+    type: 'plain';
 } | {
-    type: 'match';
-    text: string;
     groups: Array<string> | undefined;
+    text: string;
+    type: 'match';
 };
 export declare function segmentText(text: string | undefined, highlighter: TextHighlighter | undefined): Array<TextSegment>;

package/dist/types-ts4.5/render-document.d.ts

@@ -5,15 +5,15 @@ import { type AnalyticsEventPayload } from './analytics/events';
 import { type Serializer } from './serializer';
 import { type RendererAppearance } from './ui/Renderer/types';
 export interface RenderOutput<T> {
+    pmDoc?: PMNode;
     result: T;
     stat: RenderOutputStat;
-    pmDoc?: PMNode;
 }
 export interface RenderOutputStat {
     buildTreeTime?: number;
+    nodesCount?: Record<string, number>;
     sanitizeTime: number;
     serializeTime?: number;
-    nodesCount?: Record<string, number>;
 }
 export interface ResultWithTime<T> {
     output: T;

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

@@ -3,9 +3,9 @@ import { AddMarkStep } from '@atlaskit/editor-prosemirror/transform';
 export declare function isRoot(element: HTMLElement | null): boolean;
 export declare function resolvePos(node: Node | null, offset: number, findEnd?: boolean): number | false;
 interface AnnotationStepOptions {
-    schema: Schema;
     annotationId: string;
     annotationType: 'inlineComment';
+    schema: Schema;
 }
 export declare function getPosFromRange(range: Range): {
     from: number;

package/dist/types-ts4.5/types/i18n.d.ts

@@ -1,5 +1,5 @@
 export interface MessageDescriptor {
-    id: string;
-    description: string;
     defaultMessage: string;
+    description: string;
+    id: string;
 }

package/dist/types-ts4.5/types/mediaOptions.d.ts

@@ -1,14 +1,14 @@
 import type { MediaClientConfig } from '@atlaskit/media-core';
 import type { MediaFeatureFlags, SSR } from '@atlaskit/media-common';
 export type MediaSSR = {
-    mode: SSR;
     config: MediaClientConfig;
+    mode: SSR;
 };
 export interface MediaOptions {
+    allowCaptions?: boolean;
     allowLinking?: boolean;
     enableDownloadButton?: boolean;
+    enableSyncMediaCard?: boolean;
     featureFlags?: MediaFeatureFlags;
     ssr?: MediaSSR;
-    allowCaptions?: boolean;
-    enableSyncMediaCard?: boolean;
 }

package/dist/types-ts4.5/types/smartLinksOptions.d.ts

@@ -1,20 +1,6 @@
 import type React from 'react';
 import type { CardProps } from '@atlaskit/smart-card';
 export interface SmartLinksOptions {
-    /**
-     * A flag to enable inline Smart Link to render without lazy loading.
-     * Default is false.
-     *
-     * Component: inline
-     */
-    ssr?: boolean;
-    /**
-     * A flag to disable hover preview on inline Smart Link.
-     * Default is false.
-     *
-     * Component: inline
-     */
-    hideHoverPreview?: boolean;
     /**
      * Configure visibility of actions available.
      * By default, smart links show all actions available on the views.
@@ -24,6 +10,13 @@ export interface SmartLinksOptions {
      * Component: inline (hover preview), block (card)
      */
     actionOptions?: CardProps['actionOptions'];
+    /**
+     * Competitor Prompt Component for Competitor link
+     */
+    CompetitorPrompt?: React.ComponentType<{
+        linkType?: string;
+        sourceUrl: string;
+    }>;
     /**
      * A prop that determines the style of a frame:
      * whether to show it, hide it or only show it when a user hovers over embed.
@@ -33,10 +26,17 @@ export interface SmartLinksOptions {
      */
     frameStyle?: CardProps['frameStyle'];
     /**
-     * Competitor Prompt Component for Competitor link
+     * A flag to disable hover preview on inline Smart Link.
+     * Default is false.
+     *
+     * Component: inline
      */
-    CompetitorPrompt?: React.ComponentType<{
-        sourceUrl: string;
-        linkType?: string;
-    }>;
+    hideHoverPreview?: boolean;
+    /**
+     * A flag to enable inline Smart Link to render without lazy loading.
+     * Default is false.
+     *
+     * Component: inline
+     */
+    ssr?: boolean;
 }

package/dist/types-ts4.5/ui/Expand.d.ts

@@ -3,12 +3,12 @@ import type { WrappedComponentProps } from 'react-intl-next';
 import type { AnalyticsEventPayload } from '../analytics/events';
 import type { RendererAppearance } from './Renderer/types';
 export interface ExpandProps {
-    title: string;
-    nodeType: 'expand' | 'nestedExpand';
     children: React.ReactNode;
     fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
     nestedHeaderIds?: Array<string>;
+    nodeType: 'expand' | 'nestedExpand';
     rendererAppearance?: RendererAppearance;
+    title: string;
 }
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<ExpandProps & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<ExpandProps & WrappedComponentProps>;

package/dist/types-ts4.5/ui/ExtensionRenderer.d.ts

@@ -10,22 +10,22 @@ import type { ExtensionHandlers, MultiBodiedExtensionActions } from '@atlaskit/e
 import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 import type { Mark as PMMark } from '@atlaskit/editor-prosemirror/model';
 interface Props {
-    type: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
-    extensionHandlers?: ExtensionHandlers;
-    providers?: ProviderFactory;
-    rendererContext: RendererContext;
-    extensionType: string;
-    extensionKey: string;
     actions?: MultiBodiedExtensionActions;
-    text?: string;
-    parameters?: any;
+    children: ({ result }: {
+        result?: JSX.Element | null;
+    }) => JSX.Element;
     content?: any;
+    extensionHandlers?: ExtensionHandlers;
+    extensionKey: string;
+    extensionType: string;
     layout?: ExtensionLayout;
     localId?: string;
     marks?: PMMark[];
-    children: ({ result }: {
-        result?: JSX.Element | null;
-    }) => JSX.Element;
+    parameters?: any;
+    providers?: ProviderFactory;
+    rendererContext: RendererContext;
+    text?: string;
+    type: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
 }
 export default function ExtensionRenderer(props: Props): JSX.Element;
 export declare const InlineNodeRendererWrapper: ({ children, ssrPlaceholder, ssrPlaceholderReplace, }: React.PropsWithChildren<{

package/dist/types-ts4.5/ui/MediaCard.d.ts

@@ -14,33 +14,33 @@ export type MediaProvider = {
     viewMediaClientConfig: MediaClientConfig;
 };
 export interface MediaCardProps {
-    id?: string;
+    alt?: string;
+    appearance?: CardAppearance;
+    cardDimensions?: CardDimensions;
+    collection?: string;
     contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    dataAttributes?: Record<string, any>;
+    disableOverlay?: boolean;
+    enableSyncMediaCard?: boolean;
     eventHandlers?: {
         media?: {
             onClick?: CardOnClickCallback;
         };
     };
-    shouldOpenMediaViewer?: boolean;
-    type: MediaType;
-    collection?: string;
-    url?: string;
-    cardDimensions?: CardDimensions;
+    featureFlags?: MediaFeatureFlags;
+    id?: string;
+    imageStatus?: ImageStatus;
+    occurrenceKey?: string;
     originalDimensions?: NumericalCardDimensions;
-    resizeMode?: ImageResizeMode;
-    appearance?: CardAppearance;
     rendererAppearance?: RendererAppearance;
-    occurrenceKey?: string;
-    imageStatus?: ImageStatus;
-    disableOverlay?: boolean;
-    useInlinePlayer?: boolean;
     rendererContext?: RendererContext;
-    alt?: string;
-    featureFlags?: MediaFeatureFlags;
+    resizeMode?: ImageResizeMode;
     shouldEnableDownloadButton?: boolean;
+    shouldOpenMediaViewer?: boolean;
     ssr?: MediaSSR;
-    dataAttributes?: Record<string, any>;
-    enableSyncMediaCard?: boolean;
+    type: MediaType;
+    url?: string;
+    useInlinePlayer?: boolean;
 }
 interface State {
     contextIdentifierProvider?: ContextIdentifierProvider;
@@ -68,12 +68,12 @@ export declare class MediaCardView extends Component<MediaCardProps & {
     render(): React.JSX.Element | null;
 }
 export type ClipboardAttrs = {
-    id: string;
     alt?: string;
     collection?: string;
     contextIdentifierProvider?: ContextIdentifierProvider;
-    originalDimensions?: NumericalCardDimensions;
     fileState?: FileState;
+    id: string;
+    originalDimensions?: NumericalCardDimensions;
 };
 export declare const getClipboardAttrs: ({ id, alt, collection, contextIdentifierProvider, originalDimensions, fileState, }: ClipboardAttrs) => {
     [key: string]: string | number | undefined;

package/dist/types-ts4.5/ui/Renderer/ErrorBoundary.d.ts

@@ -2,17 +2,17 @@ import React from 'react';
 import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
 import type { ComponentCrashErrorAEP } from '../../analytics/events';
 interface ErrorBoundaryProps {
-    component: ComponentCrashErrorAEP['actionSubject'];
+    additionalInfo?: string;
     children: React.ReactNode;
+    component: ComponentCrashErrorAEP['actionSubject'];
     componentId?: ComponentCrashErrorAEP['actionSubjectId'];
-    fallbackComponent?: React.ReactNode;
     createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    fallbackComponent?: React.ReactNode;
     rethrowError?: boolean;
-    additionalInfo?: string;
 }
 interface ErrorBoundaryState {
-    errorCaptured: boolean;
     domError: boolean;
+    errorCaptured: boolean;
 }
 export declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
     state: {

package/dist/types-ts4.5/ui/Renderer/ValidationContext.d.ts

@@ -1,6 +1,6 @@
 type ValidationContextType = {
-    skipValidation?: boolean;
     allowNestedTables?: boolean;
+    skipValidation?: boolean;
 } | null;
 /**
  * The ValidationContext is used to pass down the `skipValidation` flag from the NBMRenderer

package/dist/types-ts4.5/ui/Renderer/index.d.ts

@@ -10,8 +10,8 @@ import type { RendererAppearance } from './types';
 export declare const NORMAL_SEVERITY_THRESHOLD = 2000;
 export declare const DEGRADED_SEVERITY_THRESHOLD = 3000;
 export declare const RendererFunctionalComponent: (props: RendererProps & {
-    startPos?: number;
     skipValidation?: boolean;
+    startPos?: number;
     validationOverrides?: {
         allowNestedTables?: boolean;
     };
@@ -24,25 +24,25 @@ export declare const RendererFunctionalComponent: (props: RendererProps & {
 export declare function Renderer(props: RendererProps): jsx.JSX.Element;
 export declare const RendererWithAnalytics: React.MemoExoticComponent<(props: RendererProps) => jsx.JSX.Element>;
 export type RendererWrapperProps = {
+    addTelepointer?: boolean;
     allowAnnotations?: boolean;
-    appearance: RendererAppearance;
-    innerRef?: React.RefObject<HTMLDivElement>;
     allowColumnSorting?: boolean;
     allowCopyToClipboard?: boolean;
-    allowWrapCodeBlock?: boolean;
-    allowPlaceholderText?: boolean;
     allowCustomPanels?: boolean;
-    addTelepointer?: boolean;
     allowNestedHeaderLinks: boolean;
-    useBlockRenderForCodeBlock: boolean;
-    onClick?: (event: React.MouseEvent) => void;
-    onMouseDown?: (event: React.MouseEvent) => void;
-    ssr?: MediaSSR;
-    isInsideOfInlineExtension?: boolean;
+    allowPlaceholderText?: boolean;
+    allowRendererContainerStyles?: boolean;
     allowTableResizing?: boolean;
+    allowWrapCodeBlock?: boolean;
+    appearance: RendererAppearance;
+    innerRef?: React.RefObject<HTMLDivElement>;
+    isInsideOfInlineExtension?: boolean;
     isTopLevelRenderer?: boolean;
+    onClick?: (event: React.MouseEvent) => void;
+    onMouseDown?: (event: React.MouseEvent) => void;
     shouldRemoveEmptySpaceAroundContent?: boolean;
-    allowRendererContainerStyles?: boolean;
+    ssr?: MediaSSR;
+    useBlockRenderForCodeBlock: boolean;
 } & {
     children?: React.ReactNode;
 };

package/dist/types-ts4.5/ui/Renderer/truncated-wrapper.d.ts

@@ -5,10 +5,10 @@
 import { jsx } from '@emotion/react';
 import { Component } from 'react';
 interface TruncatedWrapperProps {
-    height?: number;
-    fadeHeight?: number;
     backgroundColor?: string;
     children?: React.ReactNode;
+    fadeHeight?: number;
+    height?: number;
 }
 export declare class TruncatedWrapper extends Component<TruncatedWrapperProps, unknown> {
     constructor(props: TruncatedWrapperProps);

package/dist/types-ts4.5/ui/annotations/contexts/AnnotationManagerContext.d.ts

@@ -8,14 +8,14 @@ interface AnnotationState {
 }
 type AnnotationsStateRecord = Record<AnnotationId, AnnotationState>;
 interface AnnotationManagerStateContext {
-    isDrafting: boolean;
-    draftId: string | undefined;
-    draftMarkRef: HTMLElement | undefined;
-    draftActionResult: ActionResult | undefined;
     annotations: AnnotationsStateRecord;
+    currentHoveredAnnotationId: AnnotationId | undefined;
     currentSelectedAnnotationId: AnnotationId | undefined;
     currentSelectedMarkRef: HTMLElement | undefined;
-    currentHoveredAnnotationId: AnnotationId | undefined;
+    draftActionResult: ActionResult | undefined;
+    draftId: string | undefined;
+    draftMarkRef: HTMLElement | undefined;
+    isDrafting: boolean;
 }
 interface AnnotationManagerDispatchContext {
     annotationManager: AnnotationManager | undefined;
@@ -26,44 +26,44 @@ declare const AnnotationManagerDispatchContext: React.Context<AnnotationManagerD
 type AnnotationManagerAction = {
     type: 'reset';
 } | {
-    type: 'loadAnnotation';
     data: {
         id: AnnotationId;
         markState?: AnnotationMarkStates;
     }[];
+    type: 'loadAnnotation';
 } | {
-    type: 'updateAnnotation';
     data: {
-        id: AnnotationId;
-        selected?: boolean;
         hovered?: boolean;
+        id: AnnotationId;
         markState?: AnnotationMarkStates;
+        selected?: boolean;
     };
+    type: 'updateAnnotation';
 } | {
     type: 'resetSelectedAnnotation';
 } | {
     type: 'resetHoveredAnnotation';
 } | {
-    type: 'setDrafting';
     data: {
-        isDrafting: boolean;
-        draftId: string | undefined;
         draftActionResult: ActionResult | undefined;
+        draftId: string | undefined;
+        isDrafting: boolean;
     };
+    type: 'setDrafting';
 } | {
-    type: 'setDraftMarkRef';
     data: {
         draftMarkRef: HTMLElement | undefined;
     };
+    type: 'setDraftMarkRef';
 } | {
-    type: 'setSelectedMarkRef';
     data: {
         markRef: HTMLElement | undefined;
     };
+    type: 'setSelectedMarkRef';
 };
 export declare const AnnotationManagerProvider: ({ children, annotationManager, updateSubscriber, }: {
-    children?: ReactNode;
     annotationManager?: AnnotationManager;
+    children?: ReactNode;
     updateSubscriber?: AnnotationUpdateEmitter;
 }) => React.JSX.Element;
 export declare const useAnnotationManagerState: () => AnnotationManagerStateContext;

package/dist/types-ts4.5/ui/annotations/contexts/AnnotationRangeContext.d.ts

@@ -3,46 +3,46 @@ import React from 'react';
 import type { Position } from '../types';
 export type RangeType = 'selection' | 'hover' | null;
 interface AnnotationRangeStateContext {
+    hoverDraftDocumentPosition: Position | null;
+    hoverDraftRange: Range | null;
     /**
      * This range represents the selection that the user has made before they intend to save an annotation
      */
     range: Range | null;
     /**
-     * This represents the type of range that is currently set on the range property, ie, whether the range is a hover or selection.
+     * When a selection or hover is promoted to a draft, we need to store the document position of the selection or hover.
+     * This is only set once on promotion, the position should not change while the draft is open.
      */
-    type: RangeType;
+    selectionDraftDocumentPosition: Position | null;
     /**
      * This range represents the "pre-committed" placeholder range that the user will eventually save as an annotation
      * If the user does not set allowDraftMode, this will be ignored as it only is set when we call applyAnnotationDraftAt()
      */
     selectionDraftRange: Range | null;
-    hoverDraftRange: Range | null;
     /**
-     * When a selection or hover is promoted to a draft, we need to store the document position of the selection or hover.
-     * This is only set once on promotion, the position should not change while the draft is open.
+     * This represents the type of range that is currently set on the range property, ie, whether the range is a hover or selection.
      */
-    selectionDraftDocumentPosition: Position | null;
-    hoverDraftDocumentPosition: Position | null;
+    type: RangeType;
 }
 interface AnnotationRangeDispatchContext {
-    clearSelectionRange: () => void;
+    clearHoverDraft: () => void;
     clearHoverRange: () => void;
-    setSelectionRange: (range: Range) => void;
-    setHoverTarget?: (target: HTMLElement) => void;
-    promoteSelectionToDraft: (position: Position | null) => void;
-    promoteHoverToDraft: (position: Position | null) => void;
     clearSelectionDraft: () => void;
-    clearHoverDraft: () => void;
+    clearSelectionRange: () => void;
+    promoteHoverToDraft: (position: Position | null) => void;
+    promoteSelectionToDraft: (position: Position | null) => void;
+    setHoverTarget?: (target: HTMLElement) => void;
+    setSelectionRange: (range: Range) => void;
 }
 export declare const AnnotationRangeStateContext: React.Context<AnnotationRangeStateContext>;
 export declare const AnnotationRangeDispatchContext: React.Context<AnnotationRangeDispatchContext>;
 export declare const AnnotationRangeProviderInner: ({ children, allowCommentsOnMedia, }: {
-    children?: ReactNode;
     allowCommentsOnMedia?: boolean;
+    children?: ReactNode;
 }) => React.JSX.Element;
 export declare const AnnotationRangeProvider: ({ children, allowCommentsOnMedia, isNestedRender, }: {
-    children?: ReactNode;
     allowCommentsOnMedia?: boolean;
+    children?: ReactNode;
     isNestedRender?: boolean;
 }) => React.JSX.Element;
 export declare const useAnnotationRangeState: () => AnnotationRangeStateContext;

package/dist/types-ts4.5/ui/annotations/draft/component.d.ts

@@ -12,19 +12,19 @@ export declare const AnnotationDraft: ({ draftPosition, children, }: React.Props
     draftPosition: Position;
 }>) => jsx.JSX.Element;
 type ApplyAnnotationsProps = {
-    texts: string[];
-    shouldApplyAnnotationAt: InsertDraftPosition.INSIDE | InsertDraftPosition.START | InsertDraftPosition.END;
     draftPosition: Position;
-    textHighlighter?: TextHighlighter;
     marks?: readonly Mark[];
+    shouldApplyAnnotationAt: InsertDraftPosition.INSIDE | InsertDraftPosition.START | InsertDraftPosition.END;
+    textHighlighter?: TextHighlighter;
+    texts: string[];
 };
 export declare const getAnnotationIndex: (annotationPosition: InsertDraftPosition, fragmentCount: number) => number;
 export declare const applyAnnotationOnText: ({ texts, shouldApplyAnnotationAt, draftPosition, textHighlighter, marks, }: ApplyAnnotationsProps) => JSX.Element[];
 type Props = React.PropsWithChildren<{
-    startPos: number;
     endPos: number;
-    textHighlighter?: TextHighlighter;
     marks?: readonly Mark[];
+    startPos: number;
+    textHighlighter?: TextHighlighter;
 }>;
 export declare const TextWithAnnotationDraft: ({ startPos, endPos, children, textHighlighter, marks, }: Props) => jsx.JSX.Element;
 export {};

package/dist/types-ts4.5/ui/annotations/draft/text.d.ts

@@ -2,8 +2,8 @@ import React from 'react';
 import { type TextPosition, type Position } from '../types';
 export declare const findTextString: (reactNode: React.ReactNode) => string | null;
 type Offset = {
-    startOffset: number;
     endOffset: number;
+    startOffset: number;
 };
 export declare const splitText: (text: string, { startOffset, endOffset }: Offset) => string[] | null;
 export declare const calcTextSplitOffset: (position: Position, textPosition: TextPosition, text: string) => {

package/dist/types-ts4.5/ui/annotations/element/index.d.ts

@@ -1,10 +1,10 @@
 import React from 'react';
 import { type AnnotationId, type AnnotationDataAttributes, type AnnotationTypes } from '@atlaskit/adf-schema';
 type MarkElementProps = React.PropsWithChildren<{
-    id: AnnotationId;
     annotationParentIds: AnnotationId[];
-    dataAttributes: AnnotationDataAttributes;
     annotationType: AnnotationTypes;
+    dataAttributes: AnnotationDataAttributes;
+    id: AnnotationId;
     useBlockLevel?: boolean;
 }>;
 declare const MarkElement: ({ annotationParentIds, children, dataAttributes, id, useBlockLevel, }: MarkElementProps) => React.JSX.Element;

package/dist/types-ts4.5/ui/annotations/element/mark.d.ts

@@ -7,13 +7,13 @@ import type { OnAnnotationClickPayload } from '@atlaskit/editor-common/types';
 import type { AnnotationId, AnnotationDataAttributes } from '@atlaskit/adf-schema';
 import { AnnotationMarkStates } from '@atlaskit/adf-schema';
 type MarkComponentProps = {
-    id: AnnotationId;
     annotationParentIds: AnnotationId[];
     dataAttributes: AnnotationDataAttributes;
-    state: AnnotationMarkStates | null;
     hasFocus: boolean;
+    id: AnnotationId;
     isHovered: boolean;
     onClick: (props: OnAnnotationClickPayload) => void;
+    state: AnnotationMarkStates | null;
     useBlockLevel?: boolean;
 };
 export declare const MarkComponent: ({ annotationParentIds, children, dataAttributes, id, state, hasFocus, isHovered, onClick, useBlockLevel, }: React.PropsWithChildren<MarkComponentProps>) => React.ReactElement<{

package/dist/types-ts4.5/ui/annotations/hooks/use-events.d.ts

@@ -3,10 +3,10 @@ import type { AnnotationMarkStates, AnnotationId } from '@atlaskit/adf-schema';
 import { AnnotationTypes } from '@atlaskit/adf-schema';
 import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
 type ListenEventProps = {
-    id: AnnotationId;
-    updateSubscriber: AnnotationUpdateEmitter | null;
     createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    id: AnnotationId;
     isNestedRender?: boolean;
+    updateSubscriber: AnnotationUpdateEmitter | null;
 };
 type UseAnnotationUpdateSatteByEventProps = {
     type: AnnotationTypes;