@atlaskit/editor-core 188.7.0 → 188.7.3

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

@@ -0,0 +1,2 @@
+import { withReactEditorViewOuterListeners } from '@atlaskit/editor-common/ui-react';
+export default withReactEditorViewOuterListeners;

package/dist/types-ts4.5/use-preset.d.ts

@@ -0,0 +1,46 @@
+import type { DependencyList } from 'react';
+import type { EditorPresetBuilder } from '@atlaskit/editor-common/preset';
+import type { AllEditorPresetPluginTypes, ExtractPublicEditorAPI } from '@atlaskit/editor-common/types';
+interface PresetAPI<PluginNames extends string[] = [
+], StackPlugins extends AllEditorPresetPluginTypes[] = [
+]> {
+    editorApi: ExtractPublicEditorAPI<EditorPresetBuilder<PluginNames, StackPlugins>> | undefined;
+    preset: EditorPresetBuilder<PluginNames, StackPlugins>;
+}
+/**
+ * Creates a preset.
+ *
+ * Takes an input function that returns a preset (and memoizes it) depending
+ * on the dependency array provided.
+ *
+ * Returns a pluginInjectionApi in order to apply actions and subscribe to plugin
+ * changes outside of the editor.
+ *
+ * @param createPreset
+ * @param dependencies
+ * @returns PresetAPI ({ pluginInjectionApi, preset, actionBuilder })
+ *
+ * Example:
+ * ```ts
+ * function ExampleEditor() {
+ *   const { preset, editorApi } = usePreset(() =>
+ *     new EditorPresetBuilder().add(plugin1).add(plugin2)
+ *   , []);
+ *
+ *   // Can execute typesafe commands based on plugin1 or 2
+ *   const runCommand = () => editorApi.core.actions.execute(
+ *     editorApi.plugin1.commands.doSomething()
+ *   )
+ *   return (
+ *     <>
+ *       <Editor preset={preset} />
+ *       <Button onClick={runCommand}>Run command</Button>
+ *     </>
+ *   )
+ * }
+ * ```
+ */
+export declare function usePreset<PluginNames extends string[] = [
+], StackPlugins extends AllEditorPresetPluginTypes[] = [
+]>(createPreset: () => EditorPresetBuilder<PluginNames, StackPlugins>, dependencies: DependencyList): PresetAPI<PluginNames, StackPlugins>;
+export {};

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

@@ -0,0 +1,9 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { Command } from '../types/command';
+export declare function __temporaryFixForConfigPanel(editorView: EditorView): Promise<void>;
+export declare function getEditorValueWithMedia(editorView: EditorView): Promise<import("prosemirror-model").Node>;
+/**
+ * Iterates over the commands one after the other,
+ * passes the tr through and dispatches the cumulated transaction
+ */
+export declare function cascadeCommands(cmds: Command[]): Command;

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

@@ -0,0 +1 @@
+export declare function findUniqueItemsIn<T>(findIn: Array<T>, checkWith: Array<T>, comparator?: (firstItem: T, secondItem: T) => boolean): Array<T>;

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

@@ -0,0 +1 @@
+export { copyToClipboard, copyHTMLToClipboard, copyHTMLToClipboardPolyfill, } from '@atlaskit/editor-common/clipboard';

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

@@ -0,0 +1,14 @@
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { HigherOrderCommand } from '@atlaskit/editor-common/types';
+/**
+ * Creates a filter that checks if the node at a given number of parents above the current
+ * selection is of the correct node type.
+ * @param nodeType The node type to compare the nth parent against
+ * @param depthAway How many levels above the current node to check against. 0 refers to
+ * the current selection's parent, which will be the containing node when the selection
+ * is usually inside the text content.
+ */
+declare const isNthParentOfType: (nodeType: string, depthAway: number) => (state: EditorState, view?: EditorView) => boolean;
+declare const withScrollIntoView: HigherOrderCommand;
+export { isNthParentOfType, withScrollIntoView };

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

@@ -0,0 +1,8 @@
+export interface DeprecationWarning {
+    property: string;
+    description?: string;
+    type?: string;
+    condition?: (props: any) => boolean;
+}
+declare const deprecationWarnings: (className: string, props: any, deprecations: Array<DeprecationWarning>) => void;
+export default deprecationWarnings;

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

@@ -0,0 +1,6 @@
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { SimplifiedNode } from '@atlaskit/editor-common/analytics';
+export type { SimplifiedNode };
+export declare const getDocStructure: (doc: PMNode, options?: {
+    compact?: boolean;
+}) => SimplifiedNode | string;

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

@@ -0,0 +1,27 @@
+import type { Node, Schema } from '@atlaskit/editor-prosemirror/model';
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction, ReadonlyTransaction } from '@atlaskit/editor-prosemirror/state';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { Transformer, ReplaceRawValue } from '@atlaskit/editor-common/types';
+import type { DispatchAnalyticsEvent } from '../plugins/analytics/types/dispatch-analytics-event';
+import type { BreakoutMarkAttrs } from '@atlaskit/adf-schema';
+export { findFarthestParentNode, isInEmptyLine, } from '@atlaskit/editor-common/utils';
+export declare function processRawFragmentValue(schema: Schema, value?: ReplaceRawValue[], providerFactory?: ProviderFactory, sanitizePrivateContent?: boolean, contentTransformer?: Transformer<string>, dispatchAnalyticsEvent?: DispatchAnalyticsEvent): Fragment | undefined;
+export type ChangedFn = (node: Node, pos: number, parent: Node | null, index: number) => boolean | void;
+export declare function getChangedNodesIn({ tr, doc, }: {
+    tr: ReadonlyTransaction | Transaction;
+    doc: Node;
+}): {
+    node: Node;
+    pos: number;
+}[];
+export declare function getChangedNodes(tr: ReadonlyTransaction | Transaction): {
+    node: Node;
+    pos: number;
+}[];
+export declare function nodesBetweenChanged(tr: Transaction | ReadonlyTransaction, f: ChangedFn, startPos?: number): void;
+export declare function getNodesCount(node: Node): Record<string, number>;
+/**
+ * Returns a set of active child breakout modes
+ */
+export declare function getChildBreakoutModes(doc: Node, schema: Schema, filter?: BreakoutMarkAttrs['mode'][]): BreakoutMarkAttrs['mode'][];

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

@@ -0,0 +1,2 @@
+export { walkUpTreeUntil, unwrap, removeNestedEmptyEls, containsClassName, closest, closestElement, parsePx, mapElem, maphElem, } from '@atlaskit/editor-common/utils';
+export type { MapCallback } from '@atlaskit/editor-common/utils';

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

@@ -0,0 +1,2 @@
+import type { EditorProps } from '../types/editor-props';
+export default function editorDeprecationWarnings(props: EditorProps): void;

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

@@ -0,0 +1,6 @@
+import type { ExtensionProvider } from '@atlaskit/editor-common/extensions';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next/types';
+import { QuickInsertProvider } from '@atlaskit/editor-common/provider-factory';
+import EditorActions from '../actions';
+export declare function extensionProviderToQuickInsertProvider(extensionProvider: ExtensionProvider, editorActions: EditorActions, createAnalyticsEvent?: CreateUIAnalyticsEvent): Promise<QuickInsertProvider>;
+export declare function combineQuickInsertProviders(quickInsertProviders: Array<QuickInsertProvider | Promise<QuickInsertProvider>>): Promise<QuickInsertProvider>;

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

@@ -0,0 +1,23 @@
+import type { Node } from '@atlaskit/editor-prosemirror/model';
+export interface GetAttrsChange<T, V> {
+    node: Node;
+    prevAttrs?: T;
+    newAttrs: T | false | undefined;
+    options: V;
+}
+export type GetAttrsWithChangesRecorder<T, V> = {
+    getAttrs(prevAttrs?: T | undefined, node?: Node): T | false | undefined;
+    getAndResetAttrsChanges(): GetAttrsChange<T, V>[];
+};
+/**
+ * Create a new getAttrs handler who will wrap the original function,
+ * and store the changes internally to be used for other
+ * tools like Analytics later in the code.
+ *
+ * @param getAttrs - Function who gets the new attributes
+ * @return object
+ * @property handler - New handler to get indentation attributes (It wraps the original)
+ * @property getChanges - Return all the stored changes.
+ * @property clear - Clear the changes
+ */
+export default function getAttrsWithChangesRecorder<T, V>(getAttrs: (prevAttrs?: T, node?: Node) => T | false | undefined, options: V): GetAttrsWithChangesRecorder<T, V>;

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

@@ -0,0 +1,65 @@
+import type { MarkType, ResolvedPos, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Selection } from '@atlaskit/editor-prosemirror/state';
+import type { JSONDocNode } from '@atlaskit/editor-json-transformer';
+export { isEmptyNode, isSelectionInsideLastNodeInDocument, checkNodeDown, insideTableCell, isInListItem, toJSON, nodeToJSON, } from '@atlaskit/editor-common/utils';
+export { insideTable } from '@atlaskit/editor-common/core-utils';
+export { findFarthestParentNode, nodesBetweenChanged, getNodesCount, } from './document';
+export { isParagraph, isText, isLinkMark } from './nodes';
+export { setNodeSelection, setTextSelection } from './selection';
+export type { JSONDocNode };
+export { default as measurements } from './performance/measure-enum';
+export declare function getCursor(selection: Selection): ResolvedPos | undefined;
+/**
+ * Check if a mark is allowed at the current selection / cursor based on a given state.
+ * This method looks at both the currently active marks on the transaction, as well as
+ * the node and marks at the current selection to determine if the given mark type is
+ * allowed.
+ */
+export declare function isMarkTypeAllowedInCurrentSelection(markType: MarkType, state: EditorState): boolean;
+/**
+ * Repeating string for multiple times
+ */
+export declare function stringRepeat(text: string, length: number): string;
+export declare function whichTransitionEvent<TransitionEventName extends string>(): TransitionEventName | undefined;
+export declare const isTemporary: (id: string) => boolean;
+export declare const hasOpenEnd: (slice: Slice) => boolean;
+export declare const isInsideBlockQuote: (state: EditorState) => boolean;
+export { isTextSelection, isElementInTableCell, isLastItemMediaGroup, nonNullable, } from '@atlaskit/editor-common/utils';
+/** Helper type for single arg function */
+type Func<A, B> = (a: A) => B;
+type FuncN<A extends any[], B> = (...args: A) => B;
+/**
+ * Compose 1 to n functions.
+ * @param func first function
+ * @param funcs additional functions
+ */
+export declare function compose<F1 extends Func<any, any>, FN extends Array<Func<any, any>>, R extends FN extends [
+] ? F1 : FN extends [
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : FN extends [
+    any,
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : FN extends [
+    any,
+    any,
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : FN extends [
+    any,
+    any,
+    any,
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : FN extends [
+    any,
+    any,
+    any,
+    any,
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : Func<any, ReturnType<F1>>>(func: F1, ...funcs: FN): R;
+export declare function pipe(): <R>(a: R) => R;
+export declare function pipe<F extends Function>(f: F): F;
+export declare function pipe<F1 extends FuncN<any, any>>(f1: F1): (...args: Parameters<F1>) => ReturnType<F1>;
+export declare function pipe<F1 extends FuncN<any, any>, F2 extends Func<ReturnType<F1>, any>>(f1: F1, f2: F2): (...args: Parameters<F1>) => ReturnType<F2>;
+export declare function pipe<F1 extends FuncN<any, any>, F2 extends Func<ReturnType<F1>, any>, F3 extends Func<ReturnType<F2>, any>>(f1: F1, f2: F2, f3: F3): (...args: Parameters<F1>) => ReturnType<F3>;
+export declare function pipe<F1 extends FuncN<any, any>, F2 extends Func<ReturnType<F1>, any>, F3 extends Func<ReturnType<F2>, any>, FN extends Array<Func<any, any>>>(f1: F1, f2: F2, f3: F3, ...fn: FN): (...args: Parameters<F1>) => any;
+export declare function sum<T>(arr: Array<T>, f: (val: T) => number): number;
+export { SetAttrsStep } from '@atlaskit/adf-schema/steps';

package/dist/types-ts4.5/utils/is-full-page.d.ts

@@ -0,0 +1,2 @@
+import { EditorAppearance } from '../types';
+export declare function isFullPage(appearance?: EditorAppearance): boolean;

package/dist/types-ts4.5/utils/is-text-input.d.ts

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

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

@@ -0,0 +1,7 @@
+import type { Node as PMNode, MarkType } from '@atlaskit/editor-prosemirror/model';
+import type { BreakoutMarkAttrs } from '@atlaskit/adf-schema';
+export { getParentNodeWidth } from '@atlaskit/editor-common/node-width';
+/**
+ * Returns the breakout mode of a given node
+ */
+export declare const getBreakoutMode: (node: PMNode, breakout: MarkType) => BreakoutMarkAttrs['mode'] | undefined;

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

@@ -0,0 +1,8 @@
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { NodeWithPos } from '@atlaskit/editor-prosemirror/utils';
+type FindNodesByIdsOption = {
+    includeDocNode?: boolean;
+};
+export declare const findNodePosByLocalIds: (state: EditorState, ids: string[], option?: FindNodesByIdsOption) => NodeWithPos[];
+export declare const findNodePosByFragmentLocalIds: (state: EditorState, ids: string[]) => NodeWithPos[];
+export {};

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

@@ -0,0 +1 @@
+export { findChangedNodesFromTransaction, validNode, validateNodes, isType, isParagraph, isText, isLinkMark, SelectedState, isNodeSelectedOrInRange, isSupportedInParent, } from '@atlaskit/editor-common/utils';

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

@@ -0,0 +1,13 @@
+import { ACTION_SUBJECT, ACTION, FireAnalyticsCallback } from '@atlaskit/editor-common/analytics';
+type RenderActions = ACTION.RE_RENDERED;
+type RenderActionSubjects = ACTION_SUBJECT.EDITOR | ACTION_SUBJECT.REACT_EDITOR_VIEW;
+export type RenderTrackingProps<ComponentProps> = {
+    componentProps: ComponentProps;
+    action: RenderActions;
+    actionSubject: RenderActionSubjects;
+    handleAnalyticsEvent: FireAnalyticsCallback;
+    propsToIgnore?: Array<keyof ComponentProps>;
+    useShallow?: boolean;
+};
+export declare function RenderTracking<Props>(props: RenderTrackingProps<Props>): null;
+export {};

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

@@ -0,0 +1,16 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { SafePluginSpec } from '@atlaskit/editor-prosemirror/state';
+import type { EditorProps } from '../../types/editor-props';
+import type { TransactionTracker } from './track-transactions';
+import type { FeatureFlags } from '../../types/feature-flags';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+type InstrumentedPluginOptions = EditorProps['performanceTracking'] & {
+    saferDispatchedTransactions?: FeatureFlags['saferDispatchedTransactions'];
+    saferDispatchedTransactionsAnalyticsOnly?: FeatureFlags['saferDispatchedTransactionsAnalyticsOnly'];
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+};
+export declare class InstrumentedPlugin<PluginState> extends SafePlugin<PluginState> {
+    constructor(spec: SafePluginSpec, options?: InstrumentedPluginOptions, transactionTracker?: TransactionTracker);
+    static fromPlugin<T>(plugin: SafePlugin<T>, options: InstrumentedPluginOptions, transactionTracker?: TransactionTracker): InstrumentedPlugin<T>;
+}
+export {};

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

@@ -0,0 +1,8 @@
+declare const _default: {
+    EDITOR_MOUNTED: string;
+    PROSEMIRROR_RENDERED: string;
+    PROSEMIRROR_CONTENT_RENDERED: string;
+    ON_EDITOR_READY_CALLBACK: string;
+    PASTE: string;
+};
+export default _default;

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

@@ -0,0 +1 @@
+export declare const outlier: (input: number[], factor: number) => number | undefined;

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

@@ -0,0 +1 @@
+export declare const percentile: (input: number[], fraction: number) => number | undefined;

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

@@ -0,0 +1,22 @@
+import { NodesCount, PluginPerformanceReportData, PluginPerformanceReportOptions } from './plugin-performance-report';
+import { TransactionTracker } from './track-transactions';
+export declare class PluginPerformanceObserver implements PerformanceObserver {
+    private callback;
+    private getNodeCounts;
+    private getPlugins;
+    private getOptions;
+    private reportCount;
+    private simpleObserver;
+    private observer;
+    private getTransactionTracker?;
+    constructor(callback: (report: PluginPerformanceReportData) => void);
+    private get isSimpleTracking();
+    withNodeCounts(getNodeCounts: () => NodesCount): this;
+    withPlugins(getPlugins: () => string[]): this;
+    withOptions(getOptions: () => Partial<PluginPerformanceReportOptions>): this;
+    withTransactionTracker(getTransactionTracker: () => TransactionTracker): this;
+    private onObserveration;
+    observe(): void;
+    disconnect(): void;
+    takeRecords(): PerformanceEntryList;
+}

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

@@ -0,0 +1,48 @@
+import { PluginMethodReport, PluginsReport, NodeCount, PluginPerformanceReportData } from '@atlaskit/editor-common/analytics';
+export type { PluginMethodReport, PluginsReport, NodeCount, PluginPerformanceReportData, };
+export interface OutlierReport {
+    stateApplyOutlier: number | undefined;
+    viewUpdateOutlier: number | undefined;
+}
+export interface PluginPerformanceReportOptions {
+    usePerformanceMarks?: boolean;
+    samplingRate: number;
+    slowThreshold: number;
+    outlierThreshold: number;
+    outlierFactor: number;
+}
+export type NodesCount = {
+    nodeCount: NodeCount;
+    extensionNodeCount: NodeCount;
+};
+export declare class PluginPerformanceReport {
+    private entry;
+    private count;
+    private pluginNames;
+    private entryList?;
+    private stateApplied?;
+    private viewUpdated?;
+    private onChangeCalled?;
+    private onEditorViewStateUpdatedCalled?;
+    private nodes;
+    private extensionNodes;
+    private nodesDuration;
+    private plugins;
+    private slowPlugins;
+    private options;
+    private constructor();
+    static fromEntry(entry: PerformanceEntry): PluginPerformanceReport;
+    private isChild;
+    private getEntryByName;
+    private getMethodSum;
+    private greaterEquals;
+    private hasOutlierMethods;
+    get trigger(): 'none' | 'slow' | 'distribution' | 'sample';
+    get hasSlowPlugins(): boolean;
+    withEntryList(entryList: PerformanceObserverEntryList): this;
+    withPlugins(pluginNames: string[]): this;
+    withNodes(nodesCount: NodesCount, nodesDuration?: number): this;
+    withCount(count: number): this;
+    withOptions(options: Partial<PluginPerformanceReportOptions>): this;
+    toJSON(): PluginPerformanceReportData;
+}

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

@@ -0,0 +1,9 @@
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+export declare const UNSAFE_PROPERTY_SET_ERROR = "Setting an unsafe property on transaction after dispatch!";
+interface FreezeUnsafeTransactionOptions {
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    pluginKey?: string;
+    analyticsOnly?: boolean;
+}
+export declare const freezeUnsafeTransactionProperties: <TrType extends object>({ dispatchAnalyticsEvent, pluginKey, analyticsOnly, }: FreezeUnsafeTransactionOptions) => ProxyHandler<TrType>;
+export {};

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

@@ -0,0 +1,28 @@
+interface Reading {
+    name: string;
+    duration: number;
+    startTime: number;
+}
+type ObservationCallback = (entries: PerformanceObserverEntryList) => void;
+/**
+ * A class that logs and collates measurement entries until
+ * EVENT_NAME_DISPATCHTRANSACTION is detected.
+ *
+ * At that point, it will group together all the entries
+ * logged and fire a callback with all entries packaged
+ * into a PerformanceObserverEntryList.
+ *
+ * We are able to make use of this method as the measurements
+ * which occur during dispatchTransactions are synchronous.
+ */
+export declare class SimpleMeasurementLogger {
+    private currentBatch;
+    private pluginNameCache;
+    private observationCallback?;
+    setPluginNames: (names: string[]) => void;
+    setOnObservation: (callback: ObservationCallback) => void;
+    private createPerformanceEntry;
+    private convertToEntryList;
+    observed: (reading: Reading) => void;
+}
+export {};

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

@@ -0,0 +1,30 @@
+import type { TransactionTracking } from '../../types/performance-tracking';
+export declare const EVENT_NAME_STATE_APPLY = "\uD83E\uDD89 EditorView::state::apply";
+export declare const EVENT_NAME_UPDATE_STATE = "\uD83E\uDD89 EditorView::updateState";
+export declare const EVENT_NAME_VIEW_STATE_UPDATED = "\uD83E\uDD89 EditorView::onEditorViewStateUpdated";
+export declare const EVENT_NAME_ON_CHANGE = "\uD83E\uDD89 ReactEditorView::onChange";
+export declare const EVENT_NAME_DISPATCH_TRANSACTION = "\uD83E\uDD89 ReactEditorView::dispatchTransaction";
+export declare const DEFAULT_USE_PERFORMANCE_MARK = false;
+interface MeasureHelpers {
+    startMeasure: (measureName: string) => void;
+    stopMeasure: (measureName: string, onMeasureComplete?: (duration: number, startTime: number) => void) => void;
+}
+interface SimpleEntry {
+    name: string;
+    duration: number;
+    startTime: number;
+}
+type MeasureListener = (entry: SimpleEntry) => void;
+export declare class TransactionTracker {
+    private dispatchCallCounter;
+    private readonly measureMap;
+    private readonly measureListeners;
+    addMeasureListener(listener: MeasureListener): void;
+    removeMeasureListener(listener: MeasureListener): void;
+    shouldTrackTransaction(options: TransactionTracking): boolean;
+    bumpDispatchCounter: (options: TransactionTracking) => number;
+    getMeasureHelpers: (options: TransactionTracking) => MeasureHelpers;
+    private startMeasureSimple;
+    private stopMeasureSimple;
+}
+export {};

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

@@ -0,0 +1,2 @@
+declare const pickBy: (test: (key: string, value: any) => boolean, object: any) => any;
+export default pickBy;

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

@@ -0,0 +1,2 @@
+export type { Reducer } from '@atlaskit/editor-common/utils';
+export { pluginFactory } from '@atlaskit/editor-common/utils';

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

@@ -0,0 +1,5 @@
+import type { ExtensionProvider } from '@atlaskit/editor-common/extensions';
+import type EditorActions from '../actions';
+import type { ExtensionProvidersProp } from '../types/editor-props';
+declare const prepareExtensionProvider: (getEditorActions: () => EditorActions) => (extensionProviders?: ExtensionProvidersProp) => ExtensionProvider | undefined;
+export default prepareExtensionProvider;

package/dist/types-ts4.5/utils/prepare-quick-insert-provider.d.ts

@@ -0,0 +1,16 @@
+import type { ExtensionProvider } from '@atlaskit/editor-common/extensions';
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next/types';
+import type { QuickInsertProvider } from '@atlaskit/editor-common/provider-factory';
+import type EditorActions from '../actions';
+import type { QuickInsertOptions } from '@atlaskit/editor-common/types';
+/**
+ *
+ * Used to combine the quickInsert provider and extension provider (if available)
+ * Or return a provider that is available (quickInsertProvider preferred)
+ * @param editorActions
+ * @param extensionProvider
+ * @param quickInsert
+ * @param createAnalyticsEvent
+ * @returns Quick insert provider if available
+ */
+export default function prepareQuickInsertProvider(editorActions: EditorActions, extensionProvider?: ExtensionProvider, quickInsert?: QuickInsertOptions, createAnalyticsEvent?: CreateUIAnalyticsEvent): Promise<QuickInsertProvider> | undefined;

package/dist/types-ts4.5/utils/react-hooks/use-abortable-effect/index.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+type AbortableEffectWithCancel = (signal: AbortSignal) => () => void;
+type AbortableEffect = (signal: AbortSignal) => void;
+/**
+ * Similar to useEffect but integrated with the AbortController to make it useful for async operations.
+ * On unmount, the abort function will be called and the signal will be passed down to the function so
+ * we get the chance to cancel any operation we want.
+ *
+ * Note: This hook follows the signature of useEffect so it can be linted if enabled through the
+ * `additionalHooks` config.
+ *
+ * @param callback
+ * @param deps
+ */
+export declare function useAbortableEffect(callback: AbortableEffectWithCancel | AbortableEffect, deps: React.DependencyList): void;
+export {};

package/dist/types-ts4.5/utils/react-hooks/use-state-from-promise/index.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+type AbortableEffect<T> = () => Promise<T> | undefined;
+/**
+ * Similar to useState but deals with async values.
+ * Simply pass a promise and it will set the state when it resolves. It won't try to set if
+ * the component unmounts
+ *
+ * Note: This hook follows the signature of useEffect so it can be linted if enabled through the
+ * `additionalHooks` config.
+ *
+ * @param callback
+ * @param deps
+ */
+export declare function useStateFromPromise<S>(callback: AbortableEffect<S>, deps: React.DependencyList, initialValue?: S): [
+    S | undefined,
+    React.Dispatch<React.SetStateAction<S | undefined>>
+];
+export {};

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

@@ -0,0 +1,5 @@
+import type { EditorState, Selection } from '@atlaskit/editor-prosemirror/state';
+import type { Node } from '@atlaskit/editor-prosemirror/model';
+export { setNodeSelection, setTextSelection, setAllSelection, setCellSelection, } from '@atlaskit/editor-common/utils';
+export declare const isValidPosition: (pos: number, state: EditorState) => boolean;
+export declare const duplicateSelection: (selectionToDuplicate: Selection, doc: Node) => Selection | undefined;

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

@@ -0,0 +1,2 @@
+export { getFragmentBackingArray, mapFragment, mapSlice, flatmap, mapChildren, } from '@atlaskit/editor-common/utils';
+export type { FlatMapCallback, MapWithCallback, } from '@atlaskit/editor-common/utils';

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

@@ -0,0 +1 @@
+export { stepHasSlice, stepAddsOneOf, extractSliceFromStep, } from '@atlaskit/editor-common/utils';

package/dist/types-ts4.5/version-wrapper.d.ts

@@ -0,0 +1,3 @@
+export declare const name: string;
+export declare const version: string;
+export declare const nextMajorVersion: () => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/editor-core",
-  "version": "188.7.0",
+  "version": "188.7.3",
   "description": "A package contains Atlassian editor core functionality",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -88,7 +88,7 @@
     "@atlaskit/editor-plugin-quick-insert": "^0.2.0",
     "@atlaskit/editor-plugin-rule": "^0.1.0",
     "@atlaskit/editor-plugin-selection": "^0.1.0",
-    "@atlaskit/editor-plugin-table": "^5.0.0",
+    "@atlaskit/editor-plugin-table": "^5.1.0",
     "@atlaskit/editor-plugin-text-formatting": "^0.4.0",
     "@atlaskit/editor-plugin-type-ahead": "^0.5.0",
     "@atlaskit/editor-plugin-unsupported-content": "^0.2.0",
@@ -123,7 +123,7 @@
     "@atlaskit/textfield": "^5.6.0",
     "@atlaskit/theme": "^12.6.0",
     "@atlaskit/toggle": "^12.6.0",
-    "@atlaskit/tokens": "^1.25.0",
+    "@atlaskit/tokens": "^1.26.0",
     "@atlaskit/tooltip": "^17.8.0",
     "@atlaskit/width-detector": "^4.1.0",
     "@babel/runtime": "^7.0.0",