@atlaskit/editor-plugin-find-replace 0.1.0

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

@@ -0,0 +1,27 @@
+/** @jsx jsx */
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import { TRIGGER_METHOD } from '@atlaskit/editor-common/analytics';
+export type ReplaceProps = {
+    canReplace: boolean;
+    replaceText?: string;
+    onReplace: ({ triggerMethod, replaceText, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+        replaceText: string;
+    }) => void;
+    onReplaceAll: ({ replaceText }: {
+        replaceText: string;
+    }) => void;
+    onReplaceTextfieldRefSet: (ref: React.RefObject<HTMLInputElement>) => void;
+    onArrowUp: () => void;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+};
+export type ReplaceState = {
+    replaceText: string;
+    isComposing: boolean;
+};
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<ReplaceProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<ReplaceProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

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

@@ -0,0 +1,6 @@
+export declare const replaceSectionButtonStyles: import("@emotion/react").SerializedStyles;
+export declare const ruleStyles: import("@emotion/react").SerializedStyles;
+export declare const wrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const sectionWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const countStyles: import("@emotion/react").SerializedStyles;
+export declare const countWrapperStyles: import("@emotion/react").SerializedStyles;

package/dist/types/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/utils/batch-decorations.d.ts

@@ -0,0 +1,36 @@
+import type { Decoration, EditorView } from '@atlaskit/editor-prosemirror/view';
+/**
+ * Provides support for applying search match highlight decorations in batches
+ */
+declare class BatchDecorations {
+    private rafId?;
+    private addDecorations?;
+    private removeDecorations?;
+    stop(): void;
+    /**
+     * Applies the decorations needed for the current search results
+     * It does so async, splitting them up into batches to help with performance
+     */
+    applyAllSearchDecorations(editorView: EditorView, containerElement: HTMLElement | null, addDecorations: (decorations: Decoration[]) => void, removeDecorations: (decorations: Decoration[]) => void): Promise<void>;
+    private updateDecorationsBetween;
+    private addDecorationsBetween;
+    private removeDecorationsBetween;
+    /**
+     * Calculates Prosemirror start and end positions we want to apply the decorations
+     * between
+     * Also calculates the positions the are the start and end of the user's viewport
+     * so we can apply decorations there first and work outwards
+     */
+    private calcDecorationPositions;
+    private getStartPos;
+    private getEndPos;
+    /**
+     * Util to batch function calls by animation frames
+     * A counter will start at 0 and increment by provided value until reaches limit
+     * Passed in fn receives the counter as a param, return false to skip waiting
+     * for the animation frame for the next call
+     */
+    private batchRequests;
+}
+declare const batchDecorations: BatchDecorations;
+export default batchDecorations;

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

@@ -0,0 +1,2 @@
+import type { HigherOrderCommand } from '@atlaskit/editor-common/types';
+export declare const withScrollIntoView: HigherOrderCommand;

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

@@ -0,0 +1,49 @@
+import type { Fragment, Node as PmNode, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { ReadonlyTransaction, Selection } from '@atlaskit/editor-prosemirror/state';
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+import type { Step } from '@atlaskit/editor-prosemirror/transform';
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+import type { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import type { Match } from '../types';
+export declare function getSelectedText(selection: TextSelection): string;
+export declare const createDecorations: (selectedIndex: number, matches: {
+    start: number;
+    end: number;
+}[]) => Decoration[];
+export declare const createDecoration: (start: number, end: number, isSelected?: boolean) => Decoration;
+export declare function findMatches(content: PmNode | Fragment, searchText: string, shouldMatchCase: boolean, contentIndex?: number): Match[];
+/**
+ * Finds index of first item in matches array that comes after user's cursor pos.
+ * If `backward` is `true`, finds index of first item that comes before instead.
+ */
+export declare function findSearchIndex(selectionPos: number, matches: Match[], backward?: boolean): number;
+export declare const nextIndex: (currentIndex: number, total: number) => number;
+export declare const prevIndex: (currentIndex: number, total: number) => number;
+export declare const getSelectionForMatch: (selection: Selection, doc: PmNode, index: number, matches: Match[], offset?: number) => Selection;
+export declare const findDecorationFromMatch: (decorationSet: DecorationSet, match: Match) => Decoration | undefined;
+export declare const removeDecorationsFromSet: (decorationSet: DecorationSet, decorationsToRemove: Decoration[], doc: PmNode) => DecorationSet;
+export declare const removeMatchesFromSet: (decorationSet: DecorationSet, matches: Match[], doc: PmNode) => DecorationSet;
+/**
+ * Finds decorations in prevDecorations that are not in newDecorations or decorationsToRemove
+ * These decorations have been lost by Prosemirror during an over eager decoration removal
+ * We need to be smart to cope with thousands of decorations without crashing everything
+ */
+export declare const findLostAdjacentDecorations: (decorationsToRemove: Decoration[], prevDecorations: Decoration[], newDecorations: Decoration[]) => Decoration[];
+/**
+ * Searches through array in bumps of 100 to return the index of the first
+ * decoration whose 'from' value is before or equal to the position
+ */
+export declare const findIndexBeforePosition: (items: Decoration[], position: number) => number;
+/**
+ * Determines whether a find/replace text Match will be changed as a result
+ * of a Step modification to the document. This is evaluated by checking
+ * both mapped and unmapped versions of the Step as in different cases the
+ * matches will match.
+ *
+ * **Note:** Match state received here is after step has been applied.
+ */
+export declare const isMatchAffectedByStep: (match: Match, step: Step & {
+    from: number;
+    to: number;
+    slice: Slice;
+}, tr: ReadonlyTransaction) => boolean;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { FindReplaceToolbarButtonWithStateProps } from './types';
+declare const _default: React.MemoExoticComponent<({ popupsBoundariesElement, popupsMountPoint, popupsScrollableElement, isToolbarReducedSpacing, editorView, containerElement, dispatchAnalyticsEvent, featureFlags, takeFullWidth, api, }: FindReplaceToolbarButtonWithStateProps) => JSX.Element | null>;
+export default _default;

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

@@ -0,0 +1,64 @@
+import type { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import type { Match } from './types';
+export declare enum FindReplaceActionTypes {
+    ACTIVATE = "ACTIVATE",
+    FIND = "FIND",
+    UPDATE_DECORATIONS = "UPDATE_DECORATIONS",
+    FIND_NEXT = "FIND_NEXT",
+    FIND_PREVIOUS = "FIND_PREVIOUS",
+    REPLACE = "REPLACE",
+    REPLACE_ALL = "REPLACE_ALL",
+    CANCEL = "CANCEL",
+    BLUR = "BLUR",
+    TOGGLE_MATCH_CASE = "TOGGLE_MATCH_CASE"
+}
+export interface Activate {
+    type: FindReplaceActionTypes.ACTIVATE;
+    findText?: string;
+    matches?: Match[];
+    index?: number;
+}
+export interface Find {
+    type: FindReplaceActionTypes.FIND;
+    findText: string;
+    matches: Match[];
+    index: number;
+}
+export interface FindNext {
+    type: FindReplaceActionTypes.FIND_NEXT;
+    index: number;
+    decorationSet: DecorationSet;
+}
+export interface FindPrevious {
+    type: FindReplaceActionTypes.FIND_PREVIOUS;
+    index: number;
+    decorationSet: DecorationSet;
+}
+export interface Replace {
+    type: FindReplaceActionTypes.REPLACE;
+    replaceText: string;
+    decorationSet: DecorationSet;
+    matches: Match[];
+    index: number;
+}
+export interface ReplaceAll {
+    type: FindReplaceActionTypes.REPLACE_ALL;
+    replaceText: string;
+    decorationSet: DecorationSet;
+    matches: Match[];
+    index: number;
+}
+export interface Cancel {
+    type: FindReplaceActionTypes.CANCEL;
+}
+export interface Blur {
+    type: FindReplaceActionTypes.BLUR;
+}
+export interface UpdateDecorations {
+    type: FindReplaceActionTypes.UPDATE_DECORATIONS;
+    decorationSet: DecorationSet;
+}
+export interface ToggleMatchCase {
+    type: FindReplaceActionTypes.TOGGLE_MATCH_CASE;
+}
+export type FindReplaceAction = Activate | Find | FindNext | FindPrevious | Replace | ReplaceAll | Cancel | Blur | UpdateDecorations | ToggleMatchCase;

package/dist/types-ts4.5/commands-with-analytics.d.ts

@@ -0,0 +1,27 @@
+import type { EditorAnalyticsAPI, TRIGGER_METHOD } from '@atlaskit/editor-common/analytics';
+import type { Command } from '@atlaskit/editor-common/types';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+export declare const activateWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => ({ triggerMethod, }: {
+    triggerMethod: TRIGGER_METHOD.SHORTCUT | TRIGGER_METHOD.TOOLBAR;
+}) => Command;
+export declare const findWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => ({ editorView, containerElement, keyword, }: {
+    editorView: EditorView;
+    containerElement: HTMLElement | null;
+    keyword?: string | undefined;
+}) => Command;
+export declare const findNextWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => ({ triggerMethod, }: {
+    triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+}) => Command;
+export declare const findPrevWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => ({ triggerMethod, }: {
+    triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+}) => Command;
+export declare const replaceWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => ({ triggerMethod, replaceText, }: {
+    triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+    replaceText: string;
+}) => Command;
+export declare const replaceAllWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => ({ replaceText }: {
+    replaceText: string;
+}) => Command;
+export declare const cancelSearchWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => ({ triggerMethod, }: {
+    triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.TOOLBAR | TRIGGER_METHOD.BUTTON;
+}) => Command;

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

@@ -0,0 +1,12 @@
+import type { Decoration, EditorView } from '@atlaskit/editor-prosemirror/view';
+export declare const activate: () => import("@atlaskit/editor-common/types").Command;
+export declare const find: (editorView: EditorView, containerElement: HTMLElement | null, keyword?: string) => import("@atlaskit/editor-common/types").Command;
+export declare const findNext: () => import("@atlaskit/editor-common/types").Command;
+export declare const findPrevious: () => import("@atlaskit/editor-common/types").Command;
+export declare const replace: (replaceText: string) => import("@atlaskit/editor-common/types").Command;
+export declare const replaceAll: (replaceText: string) => import("@atlaskit/editor-common/types").Command;
+export declare const addDecorations: (decorations: Decoration[]) => import("@atlaskit/editor-common/types").Command;
+export declare const removeDecorations: (decorations: Decoration[]) => import("@atlaskit/editor-common/types").Command;
+export declare const cancelSearch: () => import("@atlaskit/editor-common/types").Command;
+export declare const blur: () => import("@atlaskit/editor-common/types").Command;
+export declare const toggleMatchCase: () => import("@atlaskit/editor-common/types").Command;

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

@@ -0,0 +1,2 @@
+export type { FindReplacePlugin, FindReplaceToolbarButtonActionProps, FindReplaceOptions, } from './types';
+export { findReplacePlugin } from './plugin';

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

@@ -0,0 +1,2 @@
+import type { FindReplacePlugin } from './types';
+export declare const findReplacePlugin: FindReplacePlugin;

package/dist/types-ts4.5/pm-plugins/keymap.d.ts

@@ -0,0 +1,4 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+declare const keymapPlugin: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => SafePlugin<any>;
+export default keymapPlugin;

package/dist/types-ts4.5/pm-plugins/main.d.ts

@@ -0,0 +1,5 @@
+import type { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { FindReplacePluginState } from '../types';
+export declare const initialState: FindReplacePluginState;
+export declare const createPlugin: (dispatch: Dispatch) => SafePlugin<FindReplacePluginState>;

package/dist/types-ts4.5/pm-plugins/plugin-factory.d.ts

@@ -0,0 +1,2 @@
+import type { FindReplacePluginState } from '../types';
+export declare const createCommand: <A = import("../actions").FindReplaceAction>(action: A | ((state: Readonly<import("prosemirror-state").EditorState>) => false | A), transform?: ((tr: import("prosemirror-state").Transaction, state: import("prosemirror-state").EditorState) => import("prosemirror-state").Transaction) | undefined) => import("@atlaskit/editor-common/types").Command, getPluginState: (state: import("prosemirror-state").EditorState) => FindReplacePluginState, createPluginState: (dispatch: import("@atlaskit/editor-common/event-dispatcher").Dispatch<any>, initialState: FindReplacePluginState | ((state: import("prosemirror-state").EditorState) => FindReplacePluginState)) => import("prosemirror-state").SafeStateField<FindReplacePluginState>;

package/dist/types-ts4.5/pm-plugins/plugin-key.d.ts

@@ -0,0 +1,3 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import type { FindReplacePluginState } from '../types';
+export declare const findReplacePluginKey: PluginKey<FindReplacePluginState>;

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

@@ -0,0 +1,4 @@
+import type { FindReplaceAction } from './actions';
+import type { FindReplacePluginState } from './types';
+declare const reducer: (getInitialState: () => FindReplacePluginState) => (state: FindReplacePluginState, action: FindReplaceAction) => FindReplacePluginState;
+export default reducer;

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

@@ -0,0 +1,3 @@
+export declare const searchMatchClass = "search-match";
+export declare const selectedSearchMatchClass = "selected-search-match";
+export declare const findReplaceStyles: import("@emotion/react").SerializedStyles;

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

@@ -0,0 +1,76 @@
+/// <reference types="react" />
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { ExtractInjectionAPI, FeatureFlags, NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
+import type { AnalyticsPlugin } from '@atlaskit/editor-plugin-analytics';
+import type { FeatureFlagsPlugin } from '@atlaskit/editor-plugin-feature-flags';
+import type { DecorationSet, EditorView } from '@atlaskit/editor-prosemirror/view';
+export interface FindReplacePluginState {
+    /** Whether find/replace is active, i.e. displayed */
+    isActive: boolean;
+    /**
+     * Whether we should set focus into and select all text of find textfield
+     * This will be true if user highlights a word and hits cmd+f
+     */
+    shouldFocus: boolean;
+    /** Search keyword */
+    findText: string;
+    /** Text to replace with */
+    replaceText: string;
+    /** Index of selected word in array of matches, this gets updated as user finds next/prev */
+    index: number;
+    /** Positions of find results */
+    matches: Match[];
+    /** Decorations for the search results */
+    decorationSet: DecorationSet;
+    /** Whether find/replace should match case when searching for results */
+    shouldMatchCase: boolean;
+}
+export type FindReplaceToolbarButtonWithStateProps = {
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    isToolbarReducedSpacing?: boolean;
+    editorView: EditorView;
+    containerElement: HTMLElement | null;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    takeFullWidth?: boolean;
+    featureFlags: FeatureFlags;
+    api: ExtractInjectionAPI<FindReplacePlugin> | undefined;
+};
+export type FindReplaceToolbarButtonActionProps = Omit<FindReplaceToolbarButtonWithStateProps, 'featureFlags' | 'api'>;
+type Config = {
+    takeFullWidth: boolean;
+    twoLineEditorToolbar: boolean;
+};
+export type FindReplacePlugin = NextEditorPlugin<'findReplace', {
+    pluginConfiguration: Config;
+    sharedState: FindReplacePluginState | undefined;
+    dependencies: [
+        OptionalPlugin<FeatureFlagsPlugin>,
+        OptionalPlugin<AnalyticsPlugin>
+    ];
+    actions: {
+        getToolbarButton: (params: FindReplaceToolbarButtonActionProps) => React.ReactNode;
+    };
+}>;
+export type Match = {
+    /** Start position */
+    start: number;
+    /** End position */
+    end: number;
+};
+export type TextGrouping = {
+    /** The concatenated text across nodes */
+    text: string;
+    /** Start position */
+    pos: number;
+} | null;
+export type FindReplaceOptions = {
+    allowMatchCase?: boolean;
+};
+export type MatchCaseProps = {
+    allowMatchCase?: boolean;
+    shouldMatchCase?: boolean;
+    onToggleMatchCase?: () => void;
+};
+export {};

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

@@ -0,0 +1,71 @@
+/** @jsx jsx */
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import { TRIGGER_METHOD } from '@atlaskit/editor-common/analytics';
+import type { MatchCaseProps } from '../types';
+export declare const FIND_DEBOUNCE_MS = 100;
+export type FindProps = {
+    findText?: string;
+    count: {
+        index: number;
+        total: number;
+    };
+    shouldFocus: boolean;
+    onFindBlur: () => void;
+    onFind: (findText?: string) => void;
+    onFindNext: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onFindPrev: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onFindTextfieldRefSet: (ref: React.RefObject<HTMLInputElement>) => void;
+    onCancel: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.TOOLBAR | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onArrowDown: () => void;
+} & MatchCaseProps;
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<{
+    findText?: string | undefined;
+    count: {
+        index: number;
+        total: number;
+    };
+    shouldFocus: boolean;
+    onFindBlur: () => void;
+    onFind: (findText?: string | undefined) => void;
+    onFindNext: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD;
+    }) => void;
+    onFindPrev: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD;
+    }) => void;
+    onFindTextfieldRefSet: (ref: React.RefObject<HTMLInputElement>) => void;
+    onCancel: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.TOOLBAR;
+    }) => void;
+    onArrowDown: () => void;
+} & MatchCaseProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<{
+        findText?: string | undefined;
+        count: {
+            index: number;
+            total: number;
+        };
+        shouldFocus: boolean;
+        onFindBlur: () => void;
+        onFind: (findText?: string | undefined) => void;
+        onFindNext: ({ triggerMethod, }: {
+            triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD;
+        }) => void;
+        onFindPrev: ({ triggerMethod, }: {
+            triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD;
+        }) => void;
+        onFindTextfieldRefSet: (ref: React.RefObject<HTMLInputElement>) => void;
+        onCancel: ({ triggerMethod, }: {
+            triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.TOOLBAR;
+        }) => void;
+        onArrowDown: () => void;
+    } & MatchCaseProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

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

@@ -0,0 +1,43 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { DispatchAnalyticsEvent, TRIGGER_METHOD } from '@atlaskit/editor-common/analytics';
+import type { MatchCaseProps } from '../types';
+export type FindReplaceProps = {
+    findText?: string;
+    replaceText?: string;
+    count: {
+        index: number;
+        total: number;
+    };
+    shouldFocus: boolean;
+    onFindBlur: () => void;
+    onFind: (findText?: string) => void;
+    onFindNext: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onFindPrev: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onReplace: ({ triggerMethod, replaceText, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+        replaceText: string;
+    }) => void;
+    onReplaceAll: ({ replaceText }: {
+        replaceText: string;
+    }) => void;
+    onCancel: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.TOOLBAR | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+} & MatchCaseProps;
+declare class FindReplace extends React.PureComponent<FindReplaceProps> {
+    private findTextfield;
+    private replaceTextfield?;
+    setFindTextfieldRef: (findTextfieldRef: React.RefObject<HTMLInputElement>) => void;
+    setReplaceTextfieldRef: (replaceTextfieldRef: React.RefObject<HTMLInputElement>) => void;
+    setFocusToFind: () => void;
+    setFocusToReplace: () => void;
+    render(): jsx.JSX.Element;
+}
+export default FindReplace;

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

@@ -0,0 +1,21 @@
+/** @jsx jsx */
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { FindReplaceProps } from './FindReplace';
+export interface FindReplaceToolbarButtonProps extends Omit<FindReplaceProps, 'count'> {
+    index: number;
+    numMatches: number;
+    isActive: boolean;
+    onActivate: () => void;
+    isReducedSpacing?: boolean;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    takeFullWidth: boolean;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<FindReplaceToolbarButtonProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<FindReplaceToolbarButtonProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

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

@@ -0,0 +1,18 @@
+import React from 'react';
+interface Props {
+    title: string;
+    icon: JSX.Element;
+    keymapDescription: string;
+    onClick: (ref: React.RefObject<HTMLButtonElement>) => void;
+    disabled?: boolean;
+    isPressed?: boolean;
+}
+export declare class FindReplaceTooltipButton extends React.PureComponent<Props> {
+    private buttonRef;
+    static defaultProps: {
+        keymapDescription: string;
+    };
+    handleClick: () => void;
+    render(): JSX.Element;
+}
+export {};

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

@@ -0,0 +1,27 @@
+/** @jsx jsx */
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import { TRIGGER_METHOD } from '@atlaskit/editor-common/analytics';
+export type ReplaceProps = {
+    canReplace: boolean;
+    replaceText?: string;
+    onReplace: ({ triggerMethod, replaceText, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+        replaceText: string;
+    }) => void;
+    onReplaceAll: ({ replaceText }: {
+        replaceText: string;
+    }) => void;
+    onReplaceTextfieldRefSet: (ref: React.RefObject<HTMLInputElement>) => void;
+    onArrowUp: () => void;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+};
+export type ReplaceState = {
+    replaceText: string;
+    isComposing: boolean;
+};
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<ReplaceProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<ReplaceProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

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

@@ -0,0 +1,6 @@
+export declare const replaceSectionButtonStyles: import("@emotion/react").SerializedStyles;
+export declare const ruleStyles: import("@emotion/react").SerializedStyles;
+export declare const wrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const sectionWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const countStyles: import("@emotion/react").SerializedStyles;
+export declare const countWrapperStyles: import("@emotion/react").SerializedStyles;

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/batch-decorations.d.ts

@@ -0,0 +1,36 @@
+import type { Decoration, EditorView } from '@atlaskit/editor-prosemirror/view';
+/**
+ * Provides support for applying search match highlight decorations in batches
+ */
+declare class BatchDecorations {
+    private rafId?;
+    private addDecorations?;
+    private removeDecorations?;
+    stop(): void;
+    /**
+     * Applies the decorations needed for the current search results
+     * It does so async, splitting them up into batches to help with performance
+     */
+    applyAllSearchDecorations(editorView: EditorView, containerElement: HTMLElement | null, addDecorations: (decorations: Decoration[]) => void, removeDecorations: (decorations: Decoration[]) => void): Promise<void>;
+    private updateDecorationsBetween;
+    private addDecorationsBetween;
+    private removeDecorationsBetween;
+    /**
+     * Calculates Prosemirror start and end positions we want to apply the decorations
+     * between
+     * Also calculates the positions the are the start and end of the user's viewport
+     * so we can apply decorations there first and work outwards
+     */
+    private calcDecorationPositions;
+    private getStartPos;
+    private getEndPos;
+    /**
+     * Util to batch function calls by animation frames
+     * A counter will start at 0 and increment by provided value until reaches limit
+     * Passed in fn receives the counter as a param, return false to skip waiting
+     * for the animation frame for the next call
+     */
+    private batchRequests;
+}
+declare const batchDecorations: BatchDecorations;
+export default batchDecorations;

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

@@ -0,0 +1,2 @@
+import type { HigherOrderCommand } from '@atlaskit/editor-common/types';
+export declare const withScrollIntoView: HigherOrderCommand;