@atlaskit/editor-common 74.0.0 → 74.1.0

package/dist/types/ui/OverflowShadow/shadowObserver.d.ts

@@ -2,7 +2,7 @@ export declare enum ShadowKeys {
     SHOW_LEFT_SHADOW = "showLeftShadow",
     SHOW_RIGHT_SHADOW = "showRightShadow"
 }
-export declare type ShadowsStates = {
+export type ShadowsStates = {
     [ShadowKey in ShadowKeys]: boolean;
 };
 export declare const shadowObserverClassNames: {

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

@@ -3,17 +3,17 @@ import { IntlShape, WrappedComponentProps } from 'react-intl-next';
 import type { ThemeModes } from '@atlaskit/theme/types';
 import { FireAnalyticsCallback } from '../../analytics';
 import { EventDispatcher } from '../../event-dispatcher';
-export declare type BasePortalProviderProps = {
+export type BasePortalProviderProps = {
     render: (portalProviderAPI: PortalProviderAPI) => React.ReactChild | JSX.Element | null;
     onAnalyticsEvent?: FireAnalyticsCallback;
     useAnalyticsContext?: boolean;
     themeMode?: ThemeModes;
 } & WrappedComponentProps;
-export declare type Portals = Map<HTMLElement, React.ReactChild>;
-export declare type PortalRendererState = {
+export type Portals = Map<HTMLElement, React.ReactChild>;
+export type PortalRendererState = {
     portals: Portals;
 };
-declare type MountedPortal = {
+type MountedPortal = {
     children: () => React.ReactChild | null;
     hasAnalyticsContext: boolean;
     hasIntlContext: boolean;
@@ -37,7 +37,7 @@ export declare class PortalProviderAPI extends EventDispatcher {
 export declare const PortalProvider: React.FC<import("react-intl-next").WithIntlProps<BasePortalProviderProps>> & {
     WrappedComponent: React.ComponentType<BasePortalProviderProps>;
 };
-declare type PortalProviderWithThemeProvidersProps = Omit<BasePortalProviderProps, 'intl' | 'themeMode'>;
+type PortalProviderWithThemeProvidersProps = Omit<BasePortalProviderProps, 'intl' | 'themeMode'>;
 export declare const PortalProviderWithThemeProviders: ({ onAnalyticsEvent, useAnalyticsContext, render, }: PortalProviderWithThemeProvidersProps) => JSX.Element;
 export declare class PortalRenderer extends React.Component<{
     portalProviderAPI: PortalProviderAPI;

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

@@ -0,0 +1,22 @@
+import React, { PropsWithChildren } from 'react';
+import { HandleComponent } from 're-resizable';
+import { EnabledHandles, HandleResize } from './types';
+export interface ResizableNumberSize {
+    width: number;
+    height: number;
+}
+export type ResizerProps = {
+    enable: EnabledHandles;
+    width: number;
+    handleResizeStart: () => number;
+    handleResize: HandleResize;
+    handleResizeStop: HandleResize;
+    innerPadding?: number;
+    handleClassName?: string;
+    className?: string;
+    minWidth?: number;
+    maxWidth?: number;
+    handleWrapperStyle?: React.CSSProperties;
+    handleComponent?: HandleComponent;
+};
+export default function ResizerNext(props: PropsWithChildren<ResizerProps>): JSX.Element;

package/dist/types/ui/Resizer/types.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+export type EnabledHandles = {
+    left?: boolean;
+    right?: boolean;
+};
+export type HandleResize = (newWidth: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, delta: {
+    width: number;
+    height: number;
+}) => number;
+export type HandleStyles = {
+    right?: React.CSSProperties;
+    left?: React.CSSProperties;
+};

package/dist/types/ui/Resizer/utils.d.ts

@@ -0,0 +1 @@
+export declare const handleSides: Array<'left' | 'right'>;

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

@@ -1,8 +1,8 @@
 /** @jsx jsx */
 import React from 'react';
 import { jsx } from '@emotion/react';
-export declare type Breakpoints = 'S' | 'M' | 'L';
-export declare type WidthConsumerContext = {
+export type Breakpoints = 'S' | 'M' | 'L';
+export type WidthConsumerContext = {
     width: number;
     breakpoint: Breakpoints;
 };
@@ -10,10 +10,10 @@ export declare function getBreakpoint(width?: number): Breakpoints;
 export declare function createWidthContext(width?: number): WidthConsumerContext;
 export declare const WidthContext: React.Context<WidthConsumerContext>;
 declare const Consumer: React.Consumer<WidthConsumerContext>;
-export declare type WidthProviderState = {
+export type WidthProviderState = {
     width?: number;
 };
-declare type WidthProviderProps = {
+type WidthProviderProps = {
     className?: string;
 };
 export declare class WidthProvider extends React.Component<WidthProviderProps, WidthProviderState> {

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

@@ -1,6 +1,6 @@
 import React from 'react';
 import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
-export declare type Props = {
+export type Props = {
     render: (createAnalyticsEvent?: CreateUIAnalyticsEvent) => React.ReactNode;
 };
 export declare const WithCreateAnalyticsEvent: React.ComponentType<Props>;

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

@@ -1,9 +1,9 @@
 export { default as Caption } from './Caption';
-export { default as MediaSingle, DEFAULT_IMAGE_WIDTH, DEFAULT_IMAGE_HEIGHT, wrappedLayouts, shouldAddDefaultWrappedWidth, } from './MediaSingle';
+export { default as MediaSingle, DEFAULT_IMAGE_WIDTH, DEFAULT_IMAGE_HEIGHT, shouldAddDefaultWrappedWidth, } from './MediaSingle';
 export type { Props as MediaSingleProps } from './MediaSingle';
 export { MediaSingleDimensionHelper } from './MediaSingle/styled';
 export type { MediaSingleWrapperProps as MediaSingleDimensionHelperProps } from './MediaSingle/styled';
-export { layoutSupportsWidth, calcPxFromColumns, calcPctFromPx, calcPxFromPct, calcColumnsFromPx, snapToGrid, } from './MediaSingle/grid';
+export { layoutSupportsWidth, calcPxFromColumns, calcPctFromPx, calcPxFromPct, calcColumnsFromPx, snapToGrid, calcMediaPxWidth, wrappedLayouts, } from './MediaSingle/grid';
 export { mediaLinkStyle } from './MediaSingle/link';
 export { default as Popup, findOverflowScrollParent } from './Popup';
 export type { Position as PopupPosition, Props as PopupProps } from './Popup';
@@ -25,3 +25,4 @@ export { ErrorMessage, HelperMessage, ValidMessage } from './Messages';
 export { clearNextSiblingMarginTopStyle, clearNextSiblingBlockMarkMarginTopStyle, } from './clear-next-sibling-margin-top';
 export { IntlErrorBoundary, REACT_INTL_ERROR_MESSAGE, } from './IntlErrorBoundary';
 export { default as IntlProviderIfMissingWrapper } from './IntlProviderIfMissingWrapper';
+export { default as FloatingToolbarButton } from './FloatingToolbar/Button';

package/dist/types/ui/with-outer-listeners.d.ts

@@ -1,5 +1,5 @@
 import { ComponentClass, StatelessComponent } from 'react';
-declare type SimpleEventHandler<T> = (event: T) => void;
+type SimpleEventHandler<T> = (event: T) => void;
 export interface WithOutsideClickProps {
     handleClickOutside?: SimpleEventHandler<MouseEvent>;
     handleEscapeKeydown?: SimpleEventHandler<KeyboardEvent>;

package/dist/types/ui-color/ColorPalette/Palettes/type.d.ts

@@ -5,8 +5,8 @@ export interface PaletteColor {
     border: string;
     message?: MessageDescriptor;
 }
-export declare type Palette = Array<PaletteColor>;
-export declare type PaletteTooltipMessages = {
+export type Palette = Array<PaletteColor>;
+export type PaletteTooltipMessages = {
     dark: Record<string, MessageDescriptor>;
     light: Record<string, MessageDescriptor>;
 };

package/dist/types/ui-menu/ArrowKeyNavigationProvider/types.d.ts

@@ -4,33 +4,33 @@ export interface KeyDownHandlerContext {
     handleArrowLeft: () => void;
     handleTab: () => void;
 }
-export declare type SimpleEventHandler<T> = (event: T) => void;
+export type SimpleEventHandler<T> = (event: T) => void;
 export declare enum ArrowKeyNavigationType {
     COLOR = "color",
     MENU = "menu"
 }
-export declare type ColorPaletteArrowKeyNavigationOptions = {
+export type ColorPaletteArrowKeyNavigationOptions = {
     type: ArrowKeyNavigationType.COLOR;
     selectedRowIndex: number;
     selectedColumnIndex: number;
     isOpenedByKeyboard: boolean;
     isPopupPositioned: boolean;
 };
-export declare type ColorPaletteArrowKeyNavigationProps = ColorPaletteArrowKeyNavigationOptions & {
+export type ColorPaletteArrowKeyNavigationProps = ColorPaletteArrowKeyNavigationOptions & {
     handleClose?: SimpleEventHandler<KeyboardEvent>;
     closeOnTab?: boolean;
     editorRef: React.RefObject<HTMLDivElement>;
 };
-export declare type MenuArrowKeyNavigationOptions = {
+export type MenuArrowKeyNavigationOptions = {
     type: ArrowKeyNavigationType.MENU;
     disableArrowKeyNavigation?: boolean;
     keyDownHandlerContext?: KeyDownHandlerContext;
 };
-export declare type MenuArrowKeyNavigationProviderProps = MenuArrowKeyNavigationOptions & {
+export type MenuArrowKeyNavigationProviderProps = MenuArrowKeyNavigationOptions & {
     handleClose?: SimpleEventHandler<KeyboardEvent>;
     onSelection?: (index: number) => void;
     closeOnTab?: boolean;
     editorRef: React.RefObject<HTMLDivElement>;
 };
-export declare type ArrowKeyNavigationProviderOptions = ColorPaletteArrowKeyNavigationOptions | MenuArrowKeyNavigationOptions;
-export declare type ArrowKeyNavigationProviderProps = Omit<ColorPaletteArrowKeyNavigationProps, 'editorRef'> | Omit<MenuArrowKeyNavigationProviderProps, 'editorRef'>;
+export type ArrowKeyNavigationProviderOptions = ColorPaletteArrowKeyNavigationOptions | MenuArrowKeyNavigationOptions;
+export type ArrowKeyNavigationProviderProps = Omit<ColorPaletteArrowKeyNavigationProps, 'editorRef'> | Omit<MenuArrowKeyNavigationProviderProps, 'editorRef'>;

package/dist/types/ui-menu/ToolbarButton/index.d.ts

@@ -5,7 +5,7 @@ import { PositionType } from '@atlaskit/tooltip';
 import { TOOLBAR_ACTION_SUBJECT_ID } from '../../analytics';
 import { MenuItem } from '../DropdownMenu';
 export declare const TOOLBAR_BUTTON: typeof TOOLBAR_ACTION_SUBJECT_ID;
-export declare type Props = {
+export type Props = {
     buttonId?: TOOLBAR_ACTION_SUBJECT_ID;
     className?: string;
     disabled?: boolean;
@@ -29,7 +29,7 @@ export declare type Props = {
     'aria-pressed'?: React.AriaAttributes['aria-pressed'];
     'aria-keyshortcuts'?: React.AriaAttributes['aria-keyshortcuts'];
 } & Pick<ButtonProps, 'aria-label' | 'children'>;
-export declare type ToolbarButtonRef = HTMLElement;
+export type ToolbarButtonRef = HTMLElement;
 declare const ToolbarButton: React.ForwardRefExoticComponent<{
     buttonId?: TOOLBAR_ACTION_SUBJECT_ID | undefined;
     className?: string | undefined;

package/dist/types/ui-react/ReactEditorViewContext.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { EditorView } from 'prosemirror-view';
-declare type ReactEditorViewContextProps = {
+type ReactEditorViewContextProps = {
     editorView?: EditorView;
     editorRef?: React.RefObject<HTMLDivElement>;
 };

package/dist/types/ui-react/with-react-editor-view-outer-listeners.d.ts

@@ -1,5 +1,5 @@
 import React, { ComponentClass, StatelessComponent } from 'react';
-declare type SimpleEventHandler<T> = (event: T) => void;
+type SimpleEventHandler<T> = (event: T) => void;
 export interface WithOutsideClickProps {
     handleClickOutside?: SimpleEventHandler<MouseEvent>;
     handleEscapeKeydown?: SimpleEventHandler<KeyboardEvent>;
@@ -7,5 +7,5 @@ export interface WithOutsideClickProps {
     targetRef?: any;
     closeOnTab?: boolean;
 }
-export default function withReactEditorViewOuterListeners<P>(Component: ComponentClass<P> | StatelessComponent<P>): React.FC<P & WithOutsideClickProps>;
+export default function withReactEditorViewOuterListeners<P extends {}>(Component: ComponentClass<P> | StatelessComponent<P>): React.FC<P & WithOutsideClickProps>;
 export {};

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

@@ -1,7 +1,7 @@
 import { EDITOR_APPEARANCE_CONTEXT } from '@atlaskit/analytics-namespaced-context';
 import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '../analytics';
-export declare const getAnalyticsAppearance: (appearance?: string | undefined) => EDITOR_APPEARANCE_CONTEXT | undefined;
-export declare const getAnalyticsEditorAppearance: (editorAppearance?: string | undefined) => string;
+export declare const getAnalyticsAppearance: (appearance?: string) => EDITOR_APPEARANCE_CONTEXT | undefined;
+export declare const getAnalyticsEditorAppearance: (editorAppearance?: string) => string;
 export declare const getAnalyticsEventSeverity: (duration: number, normalThreshold: number, degradedThreshold: number) => SEVERITY;
 export declare enum SEVERITY {
     NORMAL = "normal",
@@ -10,20 +10,20 @@ export declare enum SEVERITY {
 }
 export { UNSUPPORTED_CONTENT_LEVEL_SEVERITY, getUnsupportedContentLevelData, UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS, } from './unsupportedContent/get-unsupported-content-level-data';
 export type { UnsupportedContentLevelsTracking } from './unsupportedContent/get-unsupported-content-level-data';
-declare type AEP<Action, ActionSubject, ActionSubjectID, Attributes, EventType> = {
+type AEP<Action, ActionSubject, ActionSubjectID, Attributes, EventType> = {
     action: Action;
     actionSubject: ActionSubject;
     actionSubjectId?: ActionSubjectID;
     attributes?: Attributes;
     eventType: EventType;
 };
-declare type TrackAEP<Action, ActionSubject, ActionSubjectID, Attributes> = AEP<Action, ActionSubject, ActionSubjectID, Attributes, EVENT_TYPE.TRACK>;
-declare type UnsupportedContentEncounteredAEP = TrackAEP<ACTION.UNSUPPORTED_CONTENT_ENCOUNTERED, ACTION_SUBJECT.DOCUMENT, ACTION_SUBJECT_ID, {
+type TrackAEP<Action, ActionSubject, ActionSubjectID, Attributes> = AEP<Action, ActionSubject, ActionSubjectID, Attributes, EVENT_TYPE.TRACK>;
+type UnsupportedContentEncounteredAEP = TrackAEP<ACTION.UNSUPPORTED_CONTENT_ENCOUNTERED, ACTION_SUBJECT.DOCUMENT, ACTION_SUBJECT_ID, {
     unsupportedNode: Record<string, any>;
     errorCode?: String;
 }>;
-export declare type UnsupportedContentPayload = UnsupportedContentEncounteredAEP;
-export declare type UnsupportedContentTooltipPayload = AEP<ACTION.UNSUPPORTED_TOOLTIP_VIEWED, ACTION_SUBJECT.TOOLTIP, ACTION_SUBJECT_ID.ON_UNSUPPORTED_BLOCK | ACTION_SUBJECT_ID.ON_UNSUPPORTED_INLINE, {
+export type UnsupportedContentPayload = UnsupportedContentEncounteredAEP;
+export type UnsupportedContentTooltipPayload = AEP<ACTION.UNSUPPORTED_TOOLTIP_VIEWED, ACTION_SUBJECT.TOOLTIP, ACTION_SUBJECT_ID.ON_UNSUPPORTED_BLOCK | ACTION_SUBJECT_ID.ON_UNSUPPORTED_INLINE, {
     unsupportedNodeType: string | undefined;
 }, EVENT_TYPE.UI>;
 export declare const analyticsEventKey = "EDITOR_ANALYTICS_EVENT";

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

@@ -1,5 +1,5 @@
 import { Node as PMNode, Schema } from 'prosemirror-model';
-declare type Range = {
+type Range = {
     from: number;
     to: number;
 };

package/dist/types/utils/browser-extensions.d.ts

@@ -1,17 +1,17 @@
-declare type UserBrowserExtension = 'grammarly';
-export declare type UserBrowserExtensionResults = UserBrowserExtension[];
-declare type BaseOptions = {
+type UserBrowserExtension = 'grammarly';
+export type UserBrowserExtensionResults = UserBrowserExtension[];
+type BaseOptions = {
     extensions: UserBrowserExtension[];
 };
-declare type AsyncOptions = BaseOptions & {
+type AsyncOptions = BaseOptions & {
     async: true;
     asyncTimeoutMs: number;
 };
-declare type SyncOptions = BaseOptions & {
+type SyncOptions = BaseOptions & {
     async?: false;
     asyncTimeoutMs?: never;
 };
-declare type Options = BaseOptions & (SyncOptions | AsyncOptions);
+type Options = BaseOptions & (SyncOptions | AsyncOptions);
 /**
  * Call this to return a list (or a Promise of a list) of detected browser extensions.
  *

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

@@ -1,2 +1,2 @@
 import { EditorState } from 'prosemirror-state';
-export declare const getParticipantsCount: (editorState?: EditorState<any> | undefined) => any;
+export declare const getParticipantsCount: (editorState?: EditorState) => any;

package/dist/types/utils/compare-props.d.ts

@@ -1,4 +1,4 @@
-declare type ChangedData<T> = {
+type ChangedData<T> = {
     key: keyof T;
     difference?: any;
     maxDepthReached?: boolean;
@@ -6,24 +6,24 @@ declare type ChangedData<T> = {
     oldValue?: any;
     reactElementChanged?: boolean;
 };
-declare type Changed<T> = Array<ChangedData<T>>;
-export declare type PropsDifference<T> = {
+type Changed<T> = Array<ChangedData<T>>;
+export type PropsDifference<T> = {
     removed: Array<keyof T>;
     added: Array<keyof T>;
     changed: Changed<T>;
 };
-export declare type ShallowPropsDifference<T> = {
+export type ShallowPropsDifference<T> = {
     removed: Array<keyof T>;
     added: Array<keyof T>;
     changed: Array<keyof T>;
 };
 export declare const getKeys: <T>(obj: T) => (keyof T)[];
 export declare const getKeysAddedRemovedCommon: <T>(object1: T, object2: T) => {
-    added: (keyof T)[];
-    common: (keyof T)[];
-    removed: (keyof T)[];
+    added: (keyof T & keyof (T & {}))[];
+    common: (keyof T & keyof (T & {}))[];
+    removed: (keyof T & keyof (T & {}))[];
 };
-export declare const serializeValue: <T>(value: T[keyof T]) => string | T[keyof T] | {
+export declare const serializeValue: <T>(value: T[keyof T]) => string | (T[keyof T] & {}) | {
     type: string;
     keys: string[];
 } | undefined;

package/dist/types/utils/compareNodes.d.ts

@@ -16,8 +16,8 @@ interface NodeMetaGenerator<Type, Value> {
     type: Type;
     value: Value;
 }
-declare type TextNodeMeta = NodeMetaGenerator<ContentType.TEXT, string>;
-declare type NodeMeta = TextNodeMeta | NodeMetaGenerator<ContentType.NUMBER, number> | NodeMetaGenerator<ContentType.STATUS, string> | NodeMetaGenerator<ContentType.DATE, number> | NodeMetaGenerator<ContentType.MENTION, string> | NodeMetaGenerator<ContentType.LINK, string>;
+type TextNodeMeta = NodeMetaGenerator<ContentType.TEXT, string>;
+type NodeMeta = TextNodeMeta | NodeMetaGenerator<ContentType.NUMBER, number> | NodeMetaGenerator<ContentType.STATUS, string> | NodeMetaGenerator<ContentType.DATE, number> | NodeMetaGenerator<ContentType.MENTION, string> | NodeMetaGenerator<ContentType.LINK, string>;
 export declare function extractMetaFromTextNode(textNode: PMNode): NodeMeta;
 /**
  * Compare 2 prosemirror nodes and check if it's greater, equal or less than the other node

package/dist/types/utils/compose.d.ts

@@ -1,5 +1,5 @@
 /** Helper type for single arg function */
-declare type Func<A, B> = (a: A) => B;
+type Func<A, B> = (a: A) => B;
 /**
  * Compose 1 to n functions.
  * @param func first function

package/dist/types/utils/date.d.ts

@@ -11,7 +11,7 @@ export interface Date {
 }
 export declare const timestampToUTCDate: (timestamp: string | number) => Date;
 export declare const todayTimestampInUTC: () => string;
-export declare const timestampToString: (timestamp: string | number, intl: IntlShape | null, pattern?: FORMATS | undefined) => string;
+export declare const timestampToString: (timestamp: string | number, intl: IntlShape | null, pattern?: FORMATS) => string;
 export declare const timestampToIsoFormat: (timestamp: string | number) => string;
 export declare const isPastDate: (timestamp: string | number) => boolean;
 export declare const timestampToTaskContext: (timestamp: string | number, intl: IntlShape) => string;

package/dist/types/utils/dom.d.ts

@@ -35,6 +35,6 @@ export declare function closestElement(node: HTMLElement | null | undefined, s:
  */
 export declare function parsePx<PXString extends `${number}px`>(pxStr: PXString): number;
 export declare function parsePx<PXString extends string>(pxStr: PXString): number | undefined;
-export declare type MapCallback<T, S> = (elem: S, idx: number, parent: Element) => T;
+export type MapCallback<T, S> = (elem: S, idx: number, parent: Element) => T;
 export declare function mapElem<T>(elem: Element, callback: MapCallback<T, Element>): Array<T>;
 export declare function maphElem<T, U extends HTMLElement>(elem: U, callback: MapCallback<T, U>): Array<T>;

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

@@ -2,6 +2,10 @@ import { Node, NodeType, Slice } from 'prosemirror-model';
 import { EditorState, Selection, TextSelection } from 'prosemirror-state';
 import { Step } from 'prosemirror-transform';
 import { EditorView } from 'prosemirror-view';
+/**
+ * Checks if node is an empty paragraph.
+ */
+export declare function isEmptyParagraph(node?: Node | null): boolean;
 export declare const stepHasSlice: (step: Step) => step is Step<any> & {
     from: number;
     to: number;

package/dist/types/utils/error-reporter.d.ts

@@ -1,4 +1,4 @@
-export declare type ErrorReporterTags = {
+export type ErrorReporterTags = {
     [key: string]: string;
 };
 export interface ErrorReportingHandler {

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

@@ -1,2 +1,2 @@
-import { Extension, ExtensionHandler } from '../extensions/types';
-export declare function getExtensionRenderer<T>(extensionHandler: Extension<T> | ExtensionHandler<T>): ExtensionHandler<T>;
+import { Extension, ExtensionHandler, Parameters } from '../extensions/types';
+export declare function getExtensionRenderer<T extends Parameters>(extensionHandler: Extension<T> | ExtensionHandler<T>): ExtensionHandler<T>;

package/dist/types/utils/hyperlink.d.ts

@@ -0,0 +1,27 @@
+import { Schema, Slice } from 'prosemirror-model';
+import { AnalyticsEventPayload, InputMethodInsertLink } from '../analytics/types';
+export declare const FILEPATH_REGEXP: RegExp;
+export declare const DONTLINKIFY_REGEXP: RegExp;
+/**
+ * Instance of class LinkMatcher are used in autoformatting in place of Regex.
+ * Hence it has been made similar to regex with an exec method.
+ * Extending it directly from class Regex was introducing some issues, thus that has been avoided.
+ */
+export declare class LinkMatcher {
+    static create(): RegExp;
+}
+/**
+ * Adds protocol to url if needed.
+ */
+export declare function normalizeUrl(url?: string | null): string;
+export declare function linkifyContent(schema: Schema): (slice: Slice) => Slice;
+export declare function getLinkDomain(url: string): string;
+export declare function isFromCurrentDomain(url: string): boolean;
+interface filepathMatch {
+    startIndex: number;
+    endIndex: number;
+}
+export declare const findFilepaths: (text: string, offset?: number) => Array<filepathMatch>;
+export declare const isLinkInMatches: (linkStart: number, matchesList: Array<filepathMatch>) => boolean;
+export declare function getLinkCreationAnalyticsEvent(inputMethod: InputMethodInsertLink, url: string): AnalyticsEventPayload;
+export {};

package/dist/types/utils/imageLoader.d.ts

@@ -10,5 +10,5 @@ export interface ImageLoaderProps {
 export interface ImageLoaderState {
     imageStatus: ImageStatus;
 }
-export declare type ImageStatus = 'complete' | 'loading' | 'error';
+export type ImageStatus = 'complete' | 'loading' | 'error';
 export declare const withImageLoader: <P extends {}>(Wrapped: React.ComponentType<P & ImageLoaderProps>) => React.ComponentClass<P & ImageLoaderProps, any>;

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

@@ -6,7 +6,7 @@ export { default as ErrorReporter } from './error-reporter';
 export type { ErrorReportingHandler } from './error-reporter';
 export { isPastDate, timestampToIsoFormat, timestampToString, timestampToTaskContext, timestampToUTCDate, todayTimestampInUTC, } from './date';
 export type { Date } from './date';
-export { isElementInTableCell, isTextSelection, isLastItemMediaGroup, setNodeSelection, setTextSelection, nonNullable, stepAddsOneOf, stepHasSlice, extractSliceFromStep, isValidPosition, } from './editor-core-utils';
+export { isElementInTableCell, isTextSelection, isLastItemMediaGroup, setNodeSelection, setTextSelection, nonNullable, stepAddsOneOf, stepHasSlice, extractSliceFromStep, isValidPosition, isEmptyParagraph, } from './editor-core-utils';
 export { withImageLoader } from './imageLoader';
 export type { ImageLoaderProps, ImageLoaderState, ImageStatus, } from './imageLoader';
 export { absoluteBreakoutWidth, calcBreakoutWidth, calcWideWidth, breakoutConsts, calculateBreakoutStyles, calcBreakoutWidthPx, } from './breakout';
@@ -46,5 +46,6 @@ export { useComponentRenderTracking } from './performance/hooks/use-component-re
 export type { UseComponentRenderTrackingArgs } from './performance/hooks/use-component-render-tracking';
 export { isOutdatedBrowser } from './outdated-browsers';
 export { isReferencedSource, removeConnectedNodes, getChildrenInfo, getNodeName, } from './referentiality';
-export { sendLogs } from './sendLogs';
-export { getItemCounterDigitsSize, getOrderFromOrderedListNode, resolveOrder, } from './list';
+export { getItemCounterDigitsSize, getOrderFromOrderedListNode, resolveOrder, isListNode, isParagraphNode, isListItemNode, isBulletList, } from './list';
+export { isFromCurrentDomain, LinkMatcher, normalizeUrl, linkifyContent, getLinkDomain, findFilepaths, isLinkInMatches, FILEPATH_REGEXP, DONTLINKIFY_REGEXP, getLinkCreationAnalyticsEvent, } from './hyperlink';
+export declare const pmHistoryPluginKey = "history$";

package/dist/types/utils/list.d.ts

@@ -7,4 +7,8 @@ interface GetItemCounterDigitsSize {
     order?: number;
 }
 export declare const getItemCounterDigitsSize: (options: GetItemCounterDigitsSize) => number | undefined;
+export declare function isListNode(node: Node | null | undefined): boolean;
+export declare function isParagraphNode(node: Node | null | undefined): boolean;
+export declare function isListItemNode(node: Node | null | undefined): boolean;
+export declare function isBulletList(node: Node | null | undefined): boolean;
 export {};

package/dist/types/utils/nodes.d.ts

@@ -10,7 +10,7 @@ export declare const findChangedNodesFromTransaction: (tr: Transaction) => PMNod
 export declare const validNode: (node: PMNode) => boolean;
 /** Validates prosemirror nodes, and returns true only if all nodes are valid */
 export declare const validateNodes: (nodes: PMNode[]) => boolean;
-declare type PMEntities = PMNode | PMMark | null | undefined;
+type PMEntities = PMNode | PMMark | null | undefined;
 export declare const isType: (node: PMEntities, type: NodeType | MarkType | undefined) => boolean | null | undefined;
 export declare const isParagraph: (node: PMEntities, schema: Schema) => boolean | null | undefined;
 export declare const isText: (node: PMEntities, schema: Schema) => boolean | null | undefined;
@@ -31,7 +31,7 @@ export declare const isNodeSelectedOrInRange: (anchorPosition: number, headPosit
  * @param state EditorState
  * @param fragment The fragment to be checked for
  */
-export declare const isSupportedInParent: (state: EditorState, fragment: Fragment, currentAppearance?: CardAppearance | undefined) => boolean;
+export declare const isSupportedInParent: (state: EditorState, fragment: Fragment, currentAppearance?: CardAppearance) => boolean;
 /**
  * Checks if the passed in node is a media node
  * Includes media, mediaInline, mediaGroup, mediaSingle

package/dist/types/utils/performance/hooks/use-component-render-tracking/index.d.ts

@@ -1,11 +1,11 @@
 import { PropsDifference, ShallowPropsDifference } from '../../../compare-props';
-declare type PropsDiff<Props> = ShallowPropsDifference<Props> | PropsDifference<Props>;
-declare type OnRenderCb<Props = undefined> = ({ renderCount, propsDifference, }: {
+type PropsDiff<Props> = ShallowPropsDifference<Props> | PropsDifference<Props>;
+type OnRenderCb<Props = undefined> = ({ renderCount, propsDifference, }: {
     renderCount: number;
     propsDifference: PropsDiff<Props> | undefined;
     componentId: string;
 }) => void;
-export declare type UseComponentRenderTrackingArgs<Props = undefined> = {
+export type UseComponentRenderTrackingArgs<Props = undefined> = {
     onRender: OnRenderCb<Props>;
     propsDiffingOptions?: {
         enabled: boolean;

package/dist/types/utils/plugin-state-factory.d.ts

@@ -1,9 +1,9 @@
 import { EditorState, PluginKey, ReadonlyTransaction, SafeStateField, Transaction } from 'prosemirror-state';
 import { Dispatch } from '../event-dispatcher';
 import { Command } from '../types';
-export declare type Reducer<PluginState, Action> = (state: PluginState, action: Action) => PluginState;
-declare type MapState<PluginState> = (tr: ReadonlyTransaction, pluginState: PluginState, editorState: EditorState) => PluginState;
-declare type SafePlugin<PluginState, Action, InitialState extends PluginState> = {
+export type Reducer<PluginState, Action> = (state: PluginState, action: Action) => PluginState;
+type MapState<PluginState> = (tr: ReadonlyTransaction, pluginState: PluginState, editorState: EditorState) => PluginState;
+type SafePlugin<PluginState, Action, InitialState extends PluginState> = {
     createPluginState: (dispatch: Dispatch, initialState: InitialState | ((state: EditorState) => InitialState)) => SafeStateField<PluginState>;
     createCommand: <A = Action>(action: A | ((state: Readonly<EditorState>) => A | false), transform?: (tr: Transaction, state: EditorState) => Transaction) => Command;
     getPluginState: (state: EditorState) => PluginState;

package/dist/types/utils/profiler/render-count.d.ts

@@ -3,7 +3,7 @@ interface ComponentInstanceRenderCounter {
     instanceId: string;
     count: number;
 }
-declare type ProfilerData = {
+type ProfilerData = {
     enabled: boolean;
     components?: {
         [componentId: string]: {
@@ -13,7 +13,7 @@ declare type ProfilerData = {
         };
     };
 };
-declare type RenderCountProfilerInstanceParams = {
+type RenderCountProfilerInstanceParams = {
     store: Object;
 };
 export declare class RenderCountProfiler {

package/dist/types/utils/referentiality.d.ts

@@ -2,17 +2,17 @@ import { Node as PMNode } from 'prosemirror-model';
 import { EditorState } from 'prosemirror-state';
 import type { FragmentAttributes } from '@atlaskit/adf-schema/schema';
 import { ConfirmDialogChildInfo } from '../types';
-declare type LocalId = FragmentAttributes['localId'];
-declare type NodeAndTargetLinkages = {
+type LocalId = FragmentAttributes['localId'];
+type NodeAndTargetLinkages = {
     readonly localId: LocalId;
     readonly name: string;
     readonly node: PMNode;
     readonly pos: number;
     readonly targets: LocalId[];
 };
-export declare const isReferencedSource: (state: EditorState, node?: PMNode<any> | undefined) => boolean;
+export declare const isReferencedSource: (state: EditorState, node?: PMNode) => boolean;
 export declare const getConnections: (state: EditorState) => Record<string, NodeAndTargetLinkages>;
-export declare const removeConnectedNodes: (state: EditorState, node?: PMNode<any> | undefined) => import("prosemirror-state").Transaction<any>;
-export declare const getChildrenInfo: (state: EditorState, node?: PMNode<any> | undefined) => ConfirmDialogChildInfo[];
-export declare const getNodeName: (state: EditorState, node?: PMNode<any> | undefined) => string;
+export declare const removeConnectedNodes: (state: EditorState, node?: PMNode) => import("prosemirror-state").Transaction<any>;
+export declare const getChildrenInfo: (state: EditorState, node?: PMNode) => ConfirmDialogChildInfo[];
+export declare const getNodeName: (state: EditorState, node?: PMNode) => string;
 export {};

package/dist/types/utils/slice.d.ts

@@ -5,7 +5,7 @@ import { Fragment, Node, Slice } from 'prosemirror-model';
 export declare function getFragmentBackingArray(fragment: Fragment): ReadonlyArray<Node>;
 export declare function mapFragment(content: Fragment, callback: (node: Node, parent: Node | null, index: number) => Node | Node[] | Fragment | null, parent?: Node | null): Fragment<any>;
 export declare function mapSlice(slice: Slice, callback: (node: Node, parent: Node | null, index: number) => Node | Node[] | Fragment | null): Slice;
-export declare type FlatMapCallback = (node: Node, index: number, fragment: Fragment) => Node | Node[];
+export type FlatMapCallback = (node: Node, index: number, fragment: Fragment) => Node | Node[];
 export declare function flatmap(fragment: Fragment, callback: FlatMapCallback): Fragment;
-export declare type MapWithCallback<T> = (node: Node, index: number, fragment: Fragment) => T;
+export type MapWithCallback<T> = (node: Node, index: number, fragment: Fragment) => T;
 export declare function mapChildren<T>(node: Node | Fragment, callback: MapWithCallback<T>): Array<T>;

package/dist/types/utils/track-unsupported-content.d.ts

@@ -1,8 +1,8 @@
 import { Node as PMNode, Schema } from 'prosemirror-model';
 import { ACTION_SUBJECT_ID } from '../analytics';
 import { UnsupportedContentPayload, UnsupportedContentTooltipPayload } from './analytics';
-declare type DispatchAnalyticsEvent = (payload: UnsupportedContentPayload) => void;
-declare type DispatchAnalyticsEventTooltip = (payload: UnsupportedContentTooltipPayload) => void;
+type DispatchAnalyticsEvent = (payload: UnsupportedContentPayload) => void;
+type DispatchAnalyticsEventTooltip = (payload: UnsupportedContentTooltipPayload) => void;
 export declare const findAndTrackUnsupportedContentNodes: (node: PMNode, schema: Schema, dispatchAnalyticsEvent: DispatchAnalyticsEvent, ancestorHierarchy?: string) => void;
 interface UnsupportedNode {
     type: string;
@@ -15,6 +15,6 @@ interface UnsupportedNode {
         [key: string]: any;
     };
 }
-export declare const fireUnsupportedEvent: (dispatchAnalyticsEvent: DispatchAnalyticsEvent, actionSubjectId: ACTION_SUBJECT_ID, unsupportedNode: UnsupportedNode, errorCode?: string | undefined) => void;
-export declare const trackUnsupportedContentTooltipDisplayedFor: (dispatchAnalyticsEvent: DispatchAnalyticsEventTooltip, unsupportedContentType: UnsupportedContentTooltipPayload['actionSubjectId'], originalNodeType?: string | undefined) => void;
+export declare const fireUnsupportedEvent: (dispatchAnalyticsEvent: DispatchAnalyticsEvent, actionSubjectId: ACTION_SUBJECT_ID, unsupportedNode: UnsupportedNode, errorCode?: string) => void;
+export declare const trackUnsupportedContentTooltipDisplayedFor: (dispatchAnalyticsEvent: DispatchAnalyticsEventTooltip, unsupportedContentType: UnsupportedContentTooltipPayload['actionSubjectId'], originalNodeType?: string) => void;
 export {};

package/dist/types/utils/traversor.d.ts

@@ -1,4 +1,4 @@
-export declare type SubscriberCallback = (node: any) => void;
+export type SubscriberCallback = (node: any) => void;
 declare class ADFTraversor {
     private doc;
     private subscribers;