@atlaskit/editor-common 74.0.1 → 74.1.1

package/dist/types-ts4.5/utils/date.d.ts

@@ -0,0 +1,18 @@
+import { IntlShape } from 'react-intl-next';
+declare enum FORMATS {
+    ISO_FORMAT = "YYYY-MM-DD",
+    CURRENT_YEAR_FORMAT_WITHOUT_YEAR = "CURRENT_YEAR_FORMAT_WITHOUT_YEAR",
+    LOCALIZED_FORMAT = "LOCALIZED_FORMAT"
+}
+export interface Date {
+    day: number;
+    month: number;
+    year: number;
+}
+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) => 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;
+export {};

package/dist/types-ts4.5/utils/dom.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Walks a DOM tree up to the provided `stopElement`, or if falsy before.
+ * @param element
+ * @param stopElement
+ */
+export declare function walkUpTreeUntil(element: HTMLElement, shouldStop: (element: HTMLElement) => boolean): HTMLElement;
+/**
+ * Takes all children out from wrapped el and puts them directly inside
+ * the parent el, at the wrapped el's position
+ */
+export declare function unwrap(parent: HTMLElement, wrapped: HTMLElement): void;
+/**
+ * Walks up DOM removing elements if they are empty until it finds
+ * one that is not
+ */
+export declare function removeNestedEmptyEls(el: HTMLElement): void;
+/**
+ * IE11 doesn't support classList to SVGElements
+ **/
+export declare const containsClassName: (node: HTMLElement | SVGElement | null, className: string) => boolean;
+export declare function closest(node: HTMLElement | null | undefined, s: string): HTMLElement | null;
+export declare function closestElement(node: HTMLElement | null | undefined, s: string): HTMLElement | null;
+/**
+ * Util for converting a css pixel size value to a number (of pixels).
+ *
+ * ie.
+ * ```ts
+ * const pixels = parsePx('10px')
+ * //    ^$ const pixels: number
+ * ```
+ * * ```ts
+ * const pixels = parsePx('10')
+ * //    ^$ const pixels: number | undefined
+ * ```
+ */
+export declare function parsePx<PXString extends `${number}px`>(pxStr: PXString): number;
+export declare function parsePx<PXString extends string>(pxStr: PXString): number | undefined;
+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-ts4.5/utils/editor-core-utils.d.ts

@@ -0,0 +1,28 @@
+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;
+    slice: Slice;
+};
+/**
+ * Checks whether a given step is adding nodes of given nodeTypes
+ *
+ * @param step Step to check
+ * @param nodeTypes NodeTypes being added
+ */
+export declare function stepAddsOneOf(step: Step, nodeTypes: Set<NodeType>): boolean;
+export declare const extractSliceFromStep: (step: Step) => Slice | null;
+export declare const isTextSelection: (selection: Selection) => selection is TextSelection<any>;
+export declare const isElementInTableCell: (element: HTMLElement | null) => HTMLElement | null;
+export declare const isLastItemMediaGroup: (node: Node) => boolean;
+export declare const setNodeSelection: (view: EditorView, pos: number) => void;
+export declare function setTextSelection(view: EditorView, anchor: number, head?: number): void;
+export declare function nonNullable<T>(value: T): value is NonNullable<T>;
+export declare const isValidPosition: (pos: number, state: EditorState) => boolean;

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

@@ -0,0 +1,13 @@
+export type ErrorReporterTags = {
+    [key: string]: string;
+};
+export interface ErrorReportingHandler {
+    captureMessage: (msg: string, tags?: ErrorReporterTags) => void;
+    captureException: (err: Error, tags?: ErrorReporterTags) => void;
+}
+export default class ErrorReporter {
+    private handlerStorage;
+    captureMessage(msg: string, tags?: ErrorReporterTags): void;
+    captureException(err: Error, tags?: ErrorReporterTags): void;
+    set handler(handler: ErrorReportingHandler | null);
+}

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

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

package/dist/types-ts4.5/utils/get-performance-options.d.ts

@@ -0,0 +1,18 @@
+import { EditorState } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+import { AnalyticsEventPayload } from '../analytics';
+export declare function getPerformanceOptions(view: EditorView): {
+    trackingEnabled: boolean;
+    samplingRate: number;
+    slowThreshold: number;
+};
+export declare function startMeasureReactNodeViewRendered({ nodeTypeName, }: {
+    nodeTypeName: string;
+}): void;
+export declare function stopMeasureReactNodeViewRendered({ nodeTypeName, dispatchAnalyticsEvent, editorState, samplingRate, slowThreshold, }: {
+    nodeTypeName: string;
+    dispatchAnalyticsEvent(payload: AnalyticsEventPayload): void;
+    editorState: EditorState;
+    samplingRate: number;
+    slowThreshold: number;
+}): void;

package/dist/types-ts4.5/utils/getModeFromTheme.d.ts

@@ -0,0 +1 @@
+export declare function getModeFromTheme(theme: string): "light" | "dark";

package/dist/types-ts4.5/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-ts4.5/utils/imageLoader.d.ts

@@ -0,0 +1,14 @@
+import React, { ComponentType } from 'react';
+export interface ImageLoaderProps {
+    url?: string;
+    onExternalImageLoaded?: (dimensions: {
+        width: number;
+        height: number;
+    }) => void;
+    imageStatus?: ImageStatus;
+}
+export interface ImageLoaderState {
+    imageStatus: ImageStatus;
+}
+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-ts4.5/utils/index.d.ts

@@ -0,0 +1,51 @@
+export { canApplyAnnotationOnRange, getAnnotationIdsFromRange, } from './annotation';
+export { getExtensionLozengeData } from './macro';
+export type { Params } from './macro';
+export { default as browser } from './browser';
+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, 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';
+export { findChangedNodesFromTransaction, validNode, validateNodes, isType, isParagraph, isText, isLinkMark, SelectedState, isNodeSelectedOrInRange, isSupportedInParent, isMediaNode, isNodeBeforeMediaNode, } from './nodes';
+export type { Reducer } from './plugin-state-factory';
+export { pluginFactory } from './plugin-state-factory';
+export { getFragmentBackingArray, mapFragment, mapSlice, flatmap, mapChildren, } from './slice';
+export type { FlatMapCallback, MapWithCallback } from './slice';
+export { walkUpTreeUntil, unwrap, removeNestedEmptyEls, containsClassName, closest, closestElement, parsePx, mapElem, maphElem, } from './dom';
+export type { MapCallback } from './dom';
+export { default as ADFTraversor } from './traversor';
+export { analyticsEventKey, getAnalyticsAppearance, getAnalyticsEditorAppearance, getAnalyticsEventSeverity, SEVERITY, getUnsupportedContentLevelData, UNSUPPORTED_CONTENT_LEVEL_SEVERITY, UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS, } from './analytics';
+export type { UnsupportedContentTooltipPayload, UnsupportedContentPayload, UnsupportedContentLevelsTracking, } from './analytics';
+export { findAndTrackUnsupportedContentNodes } from './track-unsupported-content';
+export { getDistortedDurationMonitor, measureRender, } from './performance/measure-render';
+export { startMeasure, stopMeasure, clearMeasure } from './performance/measure';
+export { measureTTI, getTTISeverity, TTI_SEVERITY_THRESHOLD_DEFAULTS, TTI_FROM_INVOCATION_SEVERITY_THRESHOLD_DEFAULTS, } from './performance/measure-tti';
+export { isPerformanceAPIAvailable, isPerformanceObserverAvailable, } from './performance/is-performance-api-available';
+export { getResponseEndTime } from './performance/navigation';
+export { getExtensionRenderer } from './extension-handler';
+export { hasMergedCell, calcTableColumnWidths, convertProsemirrorTableNodeToArrayOfRows, } from './table';
+export { createCompareNodes } from './compareNodes';
+export { compose } from './compose';
+export { isTextInput } from './is-text-input';
+export { ZERO_WIDTH_SPACE, ZERO_WIDTH_JOINER } from './whitespace';
+export type { Diff } from './types';
+export { shouldForceTracking } from './should-force-tracking';
+export { getModeFromTheme } from './getModeFromTheme';
+export { getPerformanceOptions, startMeasureReactNodeViewRendered, stopMeasureReactNodeViewRendered, } from './get-performance-options';
+export type { UserBrowserExtensionResults } from './browser-extensions';
+export { sniffUserBrowserExtensions } from './browser-extensions';
+export { RenderCountProfiler } from './profiler/render-count';
+export { validateADFEntity, validationErrorHandler, } from './validate-using-spec';
+export { getShallowPropsDifference, getPropsDifference } from './compare-props';
+export type { ShallowPropsDifference, PropsDifference } from './compare-props';
+export { useComponentRenderTracking } from './performance/hooks/use-component-render-tracking';
+export type { UseComponentRenderTrackingArgs } from './performance/hooks/use-component-render-tracking';
+export { isOutdatedBrowser } from './outdated-browsers';
+export { isReferencedSource, removeConnectedNodes, getChildrenInfo, getNodeName, } from './referentiality';
+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-ts4.5/utils/is-text-input.d.ts

@@ -0,0 +1,2 @@
+import { ReadonlyTransaction, Transaction } from 'prosemirror-state';
+export declare const isTextInput: (tr: Transaction | ReadonlyTransaction) => boolean;

package/dist/types-ts4.5/utils/list.d.ts

@@ -0,0 +1,14 @@
+import { Node } from 'prosemirror-model';
+export declare const DEFAULT_ORDER = 1;
+export declare const resolveOrder: (order: number | undefined | string) => number | undefined;
+export declare const getOrderFromOrderedListNode: (orderedListNode: Node) => number;
+interface GetItemCounterDigitsSize {
+    itemsCount?: number;
+    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-ts4.5/utils/macro.d.ts

@@ -0,0 +1,10 @@
+import { Node as PmNode } from 'prosemirror-model';
+export interface Params {
+    node: PmNode;
+    type: 'image' | 'icon';
+}
+export declare const getExtensionLozengeData: ({ node, type, }: Params) => {
+    url: string;
+    width?: number;
+    height?: number;
+} | undefined;

package/dist/types-ts4.5/utils/nodes.d.ts

@@ -0,0 +1,49 @@
+import { Fragment, MarkType, NodeType, Mark as PMMark, Node as PMNode, ResolvedPos, Schema } from 'prosemirror-model';
+import { EditorState, Transaction } from 'prosemirror-state';
+import { CardAppearance } from '@atlaskit/smart-card';
+/**
+ * Finds all top level nodes affected by the transaction
+ * Uses from/to positions in transaction's steps to work out which nodes will
+ * be changed by the transaction
+ */
+export declare const findChangedNodesFromTransaction: (tr: Transaction) => PMNode[];
+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;
+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;
+export declare const isLinkMark: (node: PMEntities, schema: Schema) => boolean | null | undefined;
+export declare enum SelectedState {
+    selectedInRange = 0,
+    selectedInside = 1
+}
+/**
+ * Returns if the current selection from achor-head is selecting the node.
+ * If the node is not selected then null is returned.
+ * If the node is selected then an enum is returned that describes weather the node
+ * is fully selected by a range or if the "inside" of the node has been selected or clicked.
+ */
+export declare const isNodeSelectedOrInRange: (anchorPosition: number, headPosition: number, nodePosition: number, nodeSize: number) => SelectedState | null;
+/**
+ * Checks if a particular node fragment is supported in the parent
+ * @param state EditorState
+ * @param fragment The fragment to be checked for
+ */
+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
+ * @param node The PM node to be checked
+ */
+export declare const isMediaNode: (node: PMNode) => boolean;
+/**
+ * Checks if the node before selection is a media node
+ * If there is no node before, checks the node before the parent node
+ * Includes media, mediaInline, mediaGroup, mediaSingle
+ * @param $pos The position of the selection
+ * @param state The editor state
+ */
+export declare const isNodeBeforeMediaNode: ($pos: ResolvedPos, state: EditorState) => boolean;
+export {};

package/dist/types-ts4.5/utils/outdated-browsers.d.ts

@@ -0,0 +1 @@
+export declare const isOutdatedBrowser: (userAgent: string) => boolean;

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

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

package/dist/types-ts4.5/utils/performance/is-performance-api-available.d.ts

@@ -0,0 +1,3 @@
+export declare function isPerformanceAPIAvailable(): boolean;
+export declare function isPerformanceObserverAvailable(): boolean;
+export declare function isPerformanceObserverLongTaskAvailable(): boolean;

package/dist/types-ts4.5/utils/performance/measure-render.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Monitors if a pages enters a visibility state which will lead to
+ * distorted duration measurements (where the measurement uses the
+ * requestAnimationFrame api).
+ */
+export declare function getDistortedDurationMonitor(): {
+    distortedDuration: boolean;
+    /**
+     * Cleans up the document visibility event listener
+     */
+    cleanup(): void;
+};
+/**
+ * Measures time it takes to render a frame including -> style, paint, layout and composition.
+ *
+ * How does it work:
+ * 1. We mark the beginning of a render with the `startMark`
+ * 2. We schedule `requestAnimationFrame` callback for the next frame
+ * 3. Framework (e.g. prosemirror) does its magic and mounts dom nodes "synchronously"
+ * 4. When the main thread is unblocked our callback gets executed and onMeasureComplete is being called
+ *
+ * Why does it work:
+ * | javascript (framework)           | style | layout | paint | composite | javascript  | ...
+ *  | startMark + scheduling rAF |                                                       | rAF callback, endMark
+ */
+export declare function measureRender(
+/**
+ * Unique name for the measurement
+ *
+ * Important: if multiple measureRender events are fired at the same time
+ * with the same measure name -- the result will not be correct.
+ */
+measureName: string, 
+/**
+ * Call back fired when the measurement completes.
+ *
+ * Note: when this function is called when the Document.visibilityState is not
+ * visible -- the duration is likely to be misleading/inaccurate. This is due
+ * to the measurements use of the `requestAnimationFrame` api which only fires
+ * when the Document.visibilityState is visible.
+ */
+onMeasureComplete: ({ duration, startTime, distortedDuration, }: {
+    duration: number;
+    startTime: number;
+    /**
+     * Will be true when the measurement takes place in a background tab or some
+     * other case which results in the Document.visibilityState not being visible.
+     *
+     * When true -- the duration value is not useful to provide to consumers. See
+     * onMeasureComplete description for more details.
+     */
+    distortedDuration: boolean;
+}) => void): void;

package/dist/types-ts4.5/utils/performance/measure-tti.d.ts

@@ -0,0 +1,14 @@
+import { SEVERITY } from '../analytics';
+export declare function measureTTI(onMeasureComplete: (tti: number, ttiFromInvocation: number, canceled: boolean) => void, idleThreshold?: number, cancelAfter?: number, PerfObserver?: typeof window.PerformanceObserver): void;
+export declare const TTI_SEVERITY_THRESHOLD_DEFAULTS: {
+    NORMAL: number;
+    DEGRADED: number;
+};
+export declare const TTI_FROM_INVOCATION_SEVERITY_THRESHOLD_DEFAULTS: {
+    NORMAL: number;
+    DEGRADED: number;
+};
+export declare function getTTISeverity(tti: number, ttiFromInvocation: number, ttiSeverityNormalTheshold?: number, ttiSeverityDegradedThreshold?: number, ttiFromInvocationSeverityNormalThreshold?: number, ttiFromInvocationSeverityDegradedThreshold?: number): {
+    ttiSeverity: SEVERITY;
+    ttiFromInvocationSeverity: SEVERITY;
+};

package/dist/types-ts4.5/utils/performance/measure.d.ts

@@ -0,0 +1,3 @@
+export declare function startMeasure(measureName: string): void;
+export declare function stopMeasure(measureName: string, onMeasureComplete?: (duration: number, startTime: number) => void): void;
+export declare function clearMeasure(measureName: string): void;

package/dist/types-ts4.5/utils/performance/navigation.d.ts

@@ -0,0 +1 @@
+export declare function getResponseEndTime(): number | undefined;

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

@@ -0,0 +1,16 @@
+import { EditorState, PluginKey, ReadonlyTransaction, SafeStateField, Transaction } from 'prosemirror-state';
+import { Dispatch } from '../event-dispatcher';
+import { Command } from '../types';
+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;
+};
+export declare function pluginFactory<PluginState, Action, InitialState extends PluginState>(pluginKey: PluginKey, reducer: Reducer<PluginState, Action>, options?: {
+    mapping?: MapState<PluginState>;
+    onDocChanged?: MapState<PluginState>;
+    onSelectionChanged?: MapState<PluginState>;
+}): SafePlugin<PluginState, Action, InitialState>;
+export {};

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

@@ -0,0 +1,50 @@
+export declare const PROFILER_KEY = "__editorRenderCountProfiler";
+interface ComponentInstanceRenderCounter {
+    instanceId: string;
+    count: number;
+}
+type ProfilerData = {
+    enabled: boolean;
+    components?: {
+        [componentId: string]: {
+            [instanceId: string]: {
+                count: number;
+            };
+        };
+    };
+};
+type RenderCountProfilerInstanceParams = {
+    store: Object;
+};
+export declare class RenderCountProfiler {
+    /**
+     * The singleton/cached instance of RenderCountProfiler that will be shared
+     * betweenRenderCountProfiler.getInstance() calls
+     */
+    private static instance;
+    private store;
+    private constructor();
+    /**
+     * Returns the singleton/cached instance of RenderCountProfiler that
+     * currently exists. If it hasn't been instantiated yet, the singleton
+     * instance will be created using the given params. Returns the latest
+     * singleton/instance.
+     */
+    static getInstance(params: RenderCountProfilerInstanceParams): RenderCountProfiler;
+    getData(profilerKey: typeof PROFILER_KEY): ProfilerData | void;
+    enable(): void;
+    remove(): void;
+    isEnabled(): boolean;
+    setRenderCount({ componentId, renderCount, instanceId, }: {
+        componentId: string;
+        renderCount: number;
+        instanceId: string;
+    }): void;
+    getInstanceRenderCounters({ componentId, }: {
+        componentId: string;
+    }): ComponentInstanceRenderCounter[];
+    getRenderCount({ componentId }: {
+        componentId: string;
+    }): number;
+}
+export {};

package/dist/types-ts4.5/utils/referentiality.d.ts

@@ -0,0 +1,18 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import type { FragmentAttributes } from '@atlaskit/adf-schema/schema';
+import { ConfirmDialogChildInfo } from '../types';
+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) => boolean;
+export declare const getConnections: (state: EditorState) => Record<string, NodeAndTargetLinkages>;
+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-ts4.5/utils/should-force-tracking.d.ts

@@ -0,0 +1 @@
+export declare const shouldForceTracking: () => boolean;

package/dist/types-ts4.5/utils/slice.d.ts

@@ -0,0 +1,11 @@
+import { Fragment, Node, Slice } from 'prosemirror-model';
+/**
+ * A helper to get the underlying array of a fragment.
+ */
+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 type FlatMapCallback = (node: Node, index: number, fragment: Fragment) => Node | Node[];
+export declare function flatmap(fragment: Fragment, callback: FlatMapCallback): Fragment;
+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-ts4.5/utils/table.d.ts

@@ -0,0 +1,4 @@
+import { Node as PmNode } from 'prosemirror-model';
+export declare function calcTableColumnWidths(node: PmNode): number[];
+export declare function hasMergedCell(tableNode: PmNode): boolean;
+export declare function convertProsemirrorTableNodeToArrayOfRows(tableNode: PmNode): Array<Array<PmNode | null>>;

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

@@ -0,0 +1,20 @@
+import { Node as PMNode, Schema } from 'prosemirror-model';
+import { ACTION_SUBJECT_ID } from '../analytics';
+import { UnsupportedContentPayload, UnsupportedContentTooltipPayload } from './analytics';
+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;
+    ancestry: string;
+    parentType: string;
+    marks: {
+        [key: string]: any;
+    }[];
+    attrs: {
+        [key: string]: any;
+    };
+}
+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-ts4.5/utils/traversor.d.ts

@@ -0,0 +1,9 @@
+export type SubscriberCallback = (node: any) => void;
+declare class ADFTraversor {
+    private doc;
+    private subscribers;
+    constructor(doc: any);
+    subscribe(type: string, callback: SubscriberCallback): void;
+    exec(): void;
+}
+export default ADFTraversor;

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

@@ -0,0 +1,2 @@
+export type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
+export type Diff<T, K> = Omit<T, keyof K>;

package/dist/types-ts4.5/utils/unsupportedContent/get-unsupported-content-level-data.d.ts

@@ -0,0 +1,57 @@
+import type { ADFEntity } from '@atlaskit/adf-utils/types';
+export declare enum UNSUPPORTED_CONTENT_LEVEL_SEVERITY {
+    NORMAL = "normal",
+    DEGRADED = "degraded",
+    BLOCKING = "blocking"
+}
+type UnsupportedContentLevelThresholds = {
+    blocking: number;
+    degraded: number;
+};
+export type UnsupportedContentLevelsTracking = {
+    enabled: boolean;
+    thresholds?: Partial<UnsupportedContentLevelThresholds>;
+    samplingRates?: {
+        [key: string]: number;
+    };
+};
+export declare const UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS: {
+    DEGRADED: number;
+    BLOCKING: number;
+};
+/**
+ * When given a valid ADF document, this function will return an information
+ * object about the level of unsupported content in the document including:
+ *
+ * - counts: an object with the unsupportedNodes count and supportedNodes count.
+ * - percentage: the percentage of unsupported nodes in the document relative to the rest
+ * of the document content
+ * - severity: The percentage mapped to a string value. This string will be either
+ * "normal", "degraded" or "blocking" based on the threshold rules. (For e.g. if
+ * `customThresholds = { degraded: 10, blocking: 30 }`, then a document with 9%
+ * unsupported content will map to "normal", a document with 14% unsupported content
+ * will map to "degraded" and a document with 33% unsupported content will map to "blocking".)
+ *
+ * **Example usage**
+ *
+ * ```
+ * const exampleAdf = { type: 'doc', version: 1, content: [...] };
+ * const customThresholds = { degraded: 30, blocking: 50 };
+ * const data = getUnsupportedContentLevelData(exampleAdf, customThresholds);
+ *
+ * console.log(data.severity); // "normal"
+ * console.log(data.counts.percentage); // 28
+ * console.log(data.counts.unsupportedNodes); // 50
+ * console.log(data.counts.supportedNodes); // 129
+ * ```
+ *
+ */
+export declare const getUnsupportedContentLevelData: (validDocument: ADFEntity, customThresholds: UnsupportedContentLevelsTracking['thresholds']) => {
+    severity: UNSUPPORTED_CONTENT_LEVEL_SEVERITY;
+    percentage: number;
+    counts: {
+        supportedNodes: number;
+        unsupportedNodes: number;
+    };
+};
+export {};

package/dist/types-ts4.5/utils/validate-using-spec.d.ts

@@ -0,0 +1,19 @@
+import { Schema } from 'prosemirror-model';
+import type { ADFEntity } from '@atlaskit/adf-utils/types';
+import type { ErrorCallbackOptions, Validate, ValidationError } from '@atlaskit/adf-utils/validatorTypes';
+export declare const UNSUPPORTED_NODE_ATTRIBUTE = "unsupportedNodeAttribute";
+import { UnsupportedContentPayload } from './analytics';
+export type DispatchAnalyticsEvent = (event: UnsupportedContentPayload) => void;
+export declare const validationErrorHandler: (entity: ADFEntity, error: ValidationError, options: ErrorCallbackOptions, marks: string[], validate: Validate, dispatchAnalyticsEvent?: DispatchAnalyticsEvent) => ADFEntity | {
+    type: string;
+    attrs: {
+        originalValue: ADFEntity;
+    };
+} | undefined;
+export declare const validateADFEntity: (schema: Schema, node: ADFEntity, dispatchAnalyticsEvent?: DispatchAnalyticsEvent) => ADFEntity;
+export declare function wrapWithUnsupported(originalValue: ADFEntity, type?: 'block' | 'inline' | 'mark'): {
+    type: string;
+    attrs: {
+        originalValue: ADFEntity;
+    };
+};