@apollohg/react-native-rich-text-editor 2.0.0

package/dist/EditorTheme.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeEditorTheme = serializeEditorTheme;
+const EditorStyleSheetNormalization_1 = require("./EditorStyleSheetNormalization");
+const EditorMentionThemeNormalization_1 = require("./EditorMentionThemeNormalization");
+function stripUndefined(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => stripUndefined(item)).filter((item) => item !== undefined);
+    }
+    if (value != null && typeof value === 'object') {
+        const entries = Object.entries(value)
+            .map(([key, entryValue]) => [key, stripUndefined(entryValue)])
+            .filter(([, entryValue]) => entryValue !== undefined);
+        if (entries.length === 0) {
+            return undefined;
+        }
+        return Object.fromEntries(entries);
+    }
+    if (typeof value === 'number' && !Number.isFinite(value)) {
+        return undefined;
+    }
+    return value;
+}
+// Mentions are configured on the mentions addon, not on EditorTheme; native
+// still reads them from the theme payload.
+function serializeEditorTheme(theme, mentionTheme) {
+    const normalized = theme === undefined ? undefined : (0, EditorStyleSheetNormalization_1.normalizeEditorTheme)(theme);
+    const cleanedTheme = normalized && (normalized.styles || normalized.toolbar)
+        ? stripUndefined(normalized)
+        : undefined;
+    const base = cleanedTheme && typeof cleanedTheme === 'object'
+        ? cleanedTheme
+        : undefined;
+    const cleanedMentions = mentionTheme
+        ? stripUndefined((0, EditorMentionThemeNormalization_1.normalizeEditorMentionTheme)(mentionTheme))
+        : undefined;
+    if (cleanedMentions == null) {
+        return base ? JSON.stringify(base) : undefined;
+    }
+    return JSON.stringify({ version: 1, ...(base ?? {}), mentions: cleanedMentions });
+}

package/dist/EditorToolbar.d.ts

@@ -0,0 +1,4 @@
+export { type EditorToolbarListType, type EditorToolbarHeadingLevel, type EditorToolbarCommand, type EditorToolbarGroupPresentation, type EditorToolbarItemPlacement, type EditorToolbarDefaultIconId, type EditorToolbarSFSymbolIcon, type EditorToolbarMaterialIcon, type EditorToolbarIcon, type EditorToolbarButtonStyle, type EditorToolbarLeafItem, type EditorToolbarGroupChildItem, type EditorToolbarGroupItem, type EditorToolbarItem, type EditorToolbarProps, } from './EditorToolbarTypes';
+export { type EditorToolbarFrame, EditorToolbarFrameOwnerProvider, isEditorToolbarFocusPreservationActive, setActiveEditorToolbarFrameOwnerForEditor, useEditorToolbarFrames, setEditorToolbarMentionState, _setEditorToolbarFrameForTests, _resetEditorToolbarFrameRegistryForTests, _beginEditorToolbarInteractionForTests, _endEditorToolbarInteractionForTests, } from './EditorToolbarRegistry';
+export { DEFAULT_EDITOR_TOOLBAR_ITEMS } from './EditorToolbarItems';
+export { EditorToolbar } from './EditorToolbarComponent';

package/dist/EditorToolbar.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditorToolbar = exports.DEFAULT_EDITOR_TOOLBAR_ITEMS = exports._endEditorToolbarInteractionForTests = exports._beginEditorToolbarInteractionForTests = exports._resetEditorToolbarFrameRegistryForTests = exports._setEditorToolbarFrameForTests = exports.setEditorToolbarMentionState = exports.useEditorToolbarFrames = exports.setActiveEditorToolbarFrameOwnerForEditor = exports.isEditorToolbarFocusPreservationActive = exports.EditorToolbarFrameOwnerProvider = void 0;
+var EditorToolbarRegistry_1 = require("./EditorToolbarRegistry");
+Object.defineProperty(exports, "EditorToolbarFrameOwnerProvider", { enumerable: true, get: function () { return EditorToolbarRegistry_1.EditorToolbarFrameOwnerProvider; } });
+Object.defineProperty(exports, "isEditorToolbarFocusPreservationActive", { enumerable: true, get: function () { return EditorToolbarRegistry_1.isEditorToolbarFocusPreservationActive; } });
+Object.defineProperty(exports, "setActiveEditorToolbarFrameOwnerForEditor", { enumerable: true, get: function () { return EditorToolbarRegistry_1.setActiveEditorToolbarFrameOwnerForEditor; } });
+Object.defineProperty(exports, "useEditorToolbarFrames", { enumerable: true, get: function () { return EditorToolbarRegistry_1.useEditorToolbarFrames; } });
+Object.defineProperty(exports, "setEditorToolbarMentionState", { enumerable: true, get: function () { return EditorToolbarRegistry_1.setEditorToolbarMentionState; } });
+Object.defineProperty(exports, "_setEditorToolbarFrameForTests", { enumerable: true, get: function () { return EditorToolbarRegistry_1._setEditorToolbarFrameForTests; } });
+Object.defineProperty(exports, "_resetEditorToolbarFrameRegistryForTests", { enumerable: true, get: function () { return EditorToolbarRegistry_1._resetEditorToolbarFrameRegistryForTests; } });
+Object.defineProperty(exports, "_beginEditorToolbarInteractionForTests", { enumerable: true, get: function () { return EditorToolbarRegistry_1._beginEditorToolbarInteractionForTests; } });
+Object.defineProperty(exports, "_endEditorToolbarInteractionForTests", { enumerable: true, get: function () { return EditorToolbarRegistry_1._endEditorToolbarInteractionForTests; } });
+var EditorToolbarItems_1 = require("./EditorToolbarItems");
+Object.defineProperty(exports, "DEFAULT_EDITOR_TOOLBAR_ITEMS", { enumerable: true, get: function () { return EditorToolbarItems_1.DEFAULT_EDITOR_TOOLBAR_ITEMS; } });
+var EditorToolbarComponent_1 = require("./EditorToolbarComponent");
+Object.defineProperty(exports, "EditorToolbar", { enumerable: true, get: function () { return EditorToolbarComponent_1.EditorToolbar; } });

package/dist/EditorToolbarComponent.d.ts

@@ -0,0 +1,13 @@
+import { type EditorToolbarProps } from './EditorToolbarTypes';
+/**
+ * A JavaScript formatting toolbar. `RichTextEditor` renders one for you
+ * when `showToolbar` is set — reach for this component directly only to place
+ * the toolbar somewhere the editor cannot, in which case wire every handler
+ * to the editor's ref and feed it `activeState` and `historyState` from the
+ * editor's callbacks.
+ *
+ * The native keyboard-attached toolbar (`toolbarPlacement="keyboard"`) is a
+ * separate implementation that consumes the same {@link EditorToolbarItem}
+ * list.
+ */
+export declare function EditorToolbar(props: EditorToolbarProps): import("react/jsx-runtime").JSX.Element;

package/dist/EditorToolbarComponent.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditorToolbar = EditorToolbar;
+const useEditorToolbarState_1 = require("./useEditorToolbarState");
+const useEditorToolbarItems_1 = require("./useEditorToolbarItems");
+const useEditorToolbarInteractions_1 = require("./useEditorToolbarInteractions");
+const useEditorToolbarPresentation_1 = require("./useEditorToolbarPresentation");
+/**
+ * A JavaScript formatting toolbar. `RichTextEditor` renders one for you
+ * when `showToolbar` is set — reach for this component directly only to place
+ * the toolbar somewhere the editor cannot, in which case wire every handler
+ * to the editor's ref and feed it `activeState` and `historyState` from the
+ * editor's callbacks.
+ *
+ * The native keyboard-attached toolbar (`toolbarPlacement="keyboard"`) is a
+ * separate implementation that consumes the same {@link EditorToolbarItem}
+ * list.
+ */
+function EditorToolbar(props) {
+    const state = (0, useEditorToolbarState_1.useEditorToolbarState)(props);
+    const items = (0, useEditorToolbarItems_1.useEditorToolbarItems)(state);
+    const interactions = (0, useEditorToolbarInteractions_1.useEditorToolbarInteractions)({ ...state, ...items });
+    return (0, useEditorToolbarPresentation_1.useEditorToolbarPresentation)({ ...state, ...items, ...interactions });
+}

package/dist/EditorToolbarItems.d.ts

@@ -0,0 +1,9 @@
+import { type EditorToolbarDefaultIconId, type EditorToolbarIcon, type EditorToolbarItemPlacement, type EditorToolbarItem } from './EditorToolbarTypes';
+export declare function defaultIcon(id: EditorToolbarDefaultIconId): EditorToolbarIcon;
+export declare function resolveToolbarItemPlacement(placement: EditorToolbarItemPlacement | undefined): EditorToolbarItemPlacement;
+/**
+ * The toolbar layout used when `toolbarItems` is not supplied. Spread it to
+ * extend the built-in set rather than restating it:
+ * `[...DEFAULT_EDITOR_TOOLBAR_ITEMS, myItem]`.
+ */
+export declare const DEFAULT_EDITOR_TOOLBAR_ITEMS: readonly EditorToolbarItem[];

package/dist/EditorToolbarItems.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EDITOR_TOOLBAR_ITEMS = void 0;
+exports.defaultIcon = defaultIcon;
+exports.resolveToolbarItemPlacement = resolveToolbarItemPlacement;
+function defaultIcon(id) {
+    return { type: 'default', id };
+}
+function resolveToolbarItemPlacement(placement) {
+    return placement ?? 'scroll';
+}
+/**
+ * The toolbar layout used when `toolbarItems` is not supplied. Spread it to
+ * extend the built-in set rather than restating it:
+ * `[...DEFAULT_EDITOR_TOOLBAR_ITEMS, myItem]`.
+ */
+exports.DEFAULT_EDITOR_TOOLBAR_ITEMS = [
+    { type: 'mark', mark: 'bold', label: 'Bold', icon: defaultIcon('bold') },
+    { type: 'mark', mark: 'italic', label: 'Italic', icon: defaultIcon('italic') },
+    { type: 'mark', mark: 'underline', label: 'Underline', icon: defaultIcon('underline') },
+    { type: 'mark', mark: 'strike', label: 'Strikethrough', icon: defaultIcon('strike') },
+    { type: 'blockquote', label: 'Blockquote', icon: defaultIcon('blockquote') },
+    { type: 'separator' },
+    {
+        type: 'list',
+        listType: 'bullet_list',
+        label: 'Bullet List',
+        icon: defaultIcon('bulletList'),
+    },
+    {
+        type: 'list',
+        listType: 'ordered_list',
+        label: 'Ordered List',
+        icon: defaultIcon('orderedList'),
+    },
+    {
+        type: 'command',
+        command: 'indentList',
+        label: 'Indent List',
+        icon: defaultIcon('indentList'),
+    },
+    {
+        type: 'command',
+        command: 'outdentList',
+        label: 'Outdent List',
+        icon: defaultIcon('outdentList'),
+    },
+    { type: 'node', nodeType: 'hard_break', label: 'Line Break', icon: defaultIcon('lineBreak') },
+    {
+        type: 'node',
+        nodeType: 'horizontal_rule',
+        label: 'Horizontal Rule',
+        icon: defaultIcon('horizontalRule'),
+    },
+    { type: 'separator' },
+    { type: 'command', command: 'undo', label: 'Undo', icon: defaultIcon('undo') },
+    { type: 'command', command: 'redo', label: 'Redo', icon: defaultIcon('redo') },
+];

package/dist/EditorToolbarRegistry.d.ts

@@ -0,0 +1,59 @@
+import React from 'react';
+import type { MentionSuggestion } from './addons';
+import type { EditorMentionTheme } from './EditorTheme';
+export interface EditorToolbarFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export type EditorToolbarFrameListener = () => void;
+export interface EditorToolbarFrameRegistration {
+    ownerId: number | null;
+    frame: EditorToolbarFrame;
+}
+export declare const editorToolbarFrames: Map<number, EditorToolbarFrameRegistration>;
+export declare const editorToolbarFrameListeners: Set<EditorToolbarFrameListener>;
+export declare const editorToolbarMentionStateListeners: Set<EditorToolbarFrameListener>;
+export declare let nextEditorToolbarRegistrationId: number;
+export declare let activeEditorToolbarInteractions: number;
+export declare let editorToolbarFocusPreserveUntil: number;
+export declare let activeEditorToolbarFrameOwnerId: number | null;
+export declare function allocateEditorToolbarRegistrationId(): number;
+export declare const EditorToolbarFrameOwnerContext: React.Context<number | null>;
+export declare function EditorToolbarFrameOwnerProvider({ ownerId, children, }: {
+    ownerId: number;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export interface EditorToolbarMentionState {
+    ownerId: number;
+    trigger: string;
+    suggestions: readonly MentionSuggestion[];
+    theme?: EditorMentionTheme;
+    suggestionThemes?: Readonly<Record<string, EditorMentionTheme | undefined>>;
+    onSelectSuggestion: (suggestion: MentionSuggestion) => void;
+}
+export declare let editorToolbarMentionState: EditorToolbarMentionState | null;
+export declare const EDITOR_TOOLBAR_FOCUS_PRESERVE_MS = 750;
+export declare function areToolbarFramesEqual(left: EditorToolbarFrame | undefined, right: EditorToolbarFrame | undefined): boolean;
+export declare function areToolbarFrameListsEqual(left: readonly EditorToolbarFrame[], right: readonly EditorToolbarFrame[]): boolean;
+export declare function notifyEditorToolbarFrameListeners(): void;
+export declare function notifyEditorToolbarMentionStateListeners(): void;
+export declare function getEditorToolbarFramesSnapshot(ownerId: number): EditorToolbarFrame[];
+export declare function subscribeEditorToolbarMentionState(listener: EditorToolbarFrameListener): () => void;
+export declare function getEditorToolbarMentionStateSnapshot(): EditorToolbarMentionState | null;
+export declare function useEditorToolbarMentionState(): EditorToolbarMentionState | null;
+export declare function registerEditorToolbarFrame(id: number, frame: EditorToolbarFrame | null, ownerId: number | null): void;
+export declare function unregisterEditorToolbarFrame(id: number): void;
+export declare function preserveEditorToolbarFocusForNextBlur(): void;
+export declare function beginEditorToolbarInteraction(): void;
+export declare function endEditorToolbarInteraction(): void;
+export declare function isEditorToolbarFocusPreservationActive(): boolean;
+export declare function setActiveEditorToolbarFrameOwnerForEditor(ownerId: number, isActive: boolean): void;
+export declare function useEditorToolbarFrames(ownerId: number): readonly EditorToolbarFrame[];
+export declare function setEditorToolbarMentionState(ownerId: number, state: Omit<EditorToolbarMentionState, 'ownerId'> | null): void;
+export declare function _setEditorToolbarFrameForTests(id: number, frame: EditorToolbarFrame | null, ownerId?: number | null): void;
+export declare function _resetEditorToolbarFrameRegistryForTests(): void;
+export declare function _beginEditorToolbarInteractionForTests(): void;
+export declare function _endEditorToolbarInteractionForTests(): void;
+export declare const BUTTON_HIT = 44;

package/dist/EditorToolbarRegistry.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUTTON_HIT = exports.EDITOR_TOOLBAR_FOCUS_PRESERVE_MS = exports.editorToolbarMentionState = exports.EditorToolbarFrameOwnerContext = exports.activeEditorToolbarFrameOwnerId = exports.editorToolbarFocusPreserveUntil = exports.activeEditorToolbarInteractions = exports.nextEditorToolbarRegistrationId = exports.editorToolbarMentionStateListeners = exports.editorToolbarFrameListeners = exports.editorToolbarFrames = void 0;
+exports.allocateEditorToolbarRegistrationId = allocateEditorToolbarRegistrationId;
+exports.EditorToolbarFrameOwnerProvider = EditorToolbarFrameOwnerProvider;
+exports.areToolbarFramesEqual = areToolbarFramesEqual;
+exports.areToolbarFrameListsEqual = areToolbarFrameListsEqual;
+exports.notifyEditorToolbarFrameListeners = notifyEditorToolbarFrameListeners;
+exports.notifyEditorToolbarMentionStateListeners = notifyEditorToolbarMentionStateListeners;
+exports.getEditorToolbarFramesSnapshot = getEditorToolbarFramesSnapshot;
+exports.subscribeEditorToolbarMentionState = subscribeEditorToolbarMentionState;
+exports.getEditorToolbarMentionStateSnapshot = getEditorToolbarMentionStateSnapshot;
+exports.useEditorToolbarMentionState = useEditorToolbarMentionState;
+exports.registerEditorToolbarFrame = registerEditorToolbarFrame;
+exports.unregisterEditorToolbarFrame = unregisterEditorToolbarFrame;
+exports.preserveEditorToolbarFocusForNextBlur = preserveEditorToolbarFocusForNextBlur;
+exports.beginEditorToolbarInteraction = beginEditorToolbarInteraction;
+exports.endEditorToolbarInteraction = endEditorToolbarInteraction;
+exports.isEditorToolbarFocusPreservationActive = isEditorToolbarFocusPreservationActive;
+exports.setActiveEditorToolbarFrameOwnerForEditor = setActiveEditorToolbarFrameOwnerForEditor;
+exports.useEditorToolbarFrames = useEditorToolbarFrames;
+exports.setEditorToolbarMentionState = setEditorToolbarMentionState;
+exports._setEditorToolbarFrameForTests = _setEditorToolbarFrameForTests;
+exports._resetEditorToolbarFrameRegistryForTests = _resetEditorToolbarFrameRegistryForTests;
+exports._beginEditorToolbarInteractionForTests = _beginEditorToolbarInteractionForTests;
+exports._endEditorToolbarInteractionForTests = _endEditorToolbarInteractionForTests;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+exports.editorToolbarFrames = new Map();
+exports.editorToolbarFrameListeners = new Set();
+exports.editorToolbarMentionStateListeners = new Set();
+exports.nextEditorToolbarRegistrationId = 1;
+exports.activeEditorToolbarInteractions = 0;
+exports.editorToolbarFocusPreserveUntil = 0;
+exports.activeEditorToolbarFrameOwnerId = null;
+function allocateEditorToolbarRegistrationId() {
+    return exports.nextEditorToolbarRegistrationId++;
+}
+exports.EditorToolbarFrameOwnerContext = (0, react_1.createContext)(null);
+function EditorToolbarFrameOwnerProvider({ ownerId, children, }) {
+    return ((0, jsx_runtime_1.jsx)(exports.EditorToolbarFrameOwnerContext.Provider, { value: ownerId, children: children }));
+}
+exports.editorToolbarMentionState = null;
+exports.EDITOR_TOOLBAR_FOCUS_PRESERVE_MS = 750;
+function areToolbarFramesEqual(left, right) {
+    return (left?.x === right?.x &&
+        left?.y === right?.y &&
+        left?.width === right?.width &&
+        left?.height === right?.height);
+}
+function areToolbarFrameListsEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((frame, index) => areToolbarFramesEqual(frame, right[index]));
+}
+function notifyEditorToolbarFrameListeners() {
+    exports.editorToolbarFrameListeners.forEach((listener) => listener());
+}
+function notifyEditorToolbarMentionStateListeners() {
+    exports.editorToolbarMentionStateListeners.forEach((listener) => listener());
+}
+function getEditorToolbarFramesSnapshot(ownerId) {
+    return Array.from(exports.editorToolbarFrames.values())
+        .filter((registration) => registration.ownerId === ownerId ||
+        (registration.ownerId == null && exports.activeEditorToolbarFrameOwnerId === ownerId))
+        .map((registration) => registration.frame);
+}
+function subscribeEditorToolbarMentionState(listener) {
+    exports.editorToolbarMentionStateListeners.add(listener);
+    return () => {
+        exports.editorToolbarMentionStateListeners.delete(listener);
+    };
+}
+function getEditorToolbarMentionStateSnapshot() {
+    return exports.editorToolbarMentionState;
+}
+function useEditorToolbarMentionState() {
+    return (0, react_1.useSyncExternalStore)(subscribeEditorToolbarMentionState, getEditorToolbarMentionStateSnapshot, getEditorToolbarMentionStateSnapshot);
+}
+function registerEditorToolbarFrame(id, frame, ownerId) {
+    if (frame == null || frame.width <= 0 || frame.height <= 0) {
+        if (exports.editorToolbarFrames.delete(id)) {
+            notifyEditorToolbarFrameListeners();
+        }
+        return;
+    }
+    const currentRegistration = exports.editorToolbarFrames.get(id);
+    if (currentRegistration?.ownerId === ownerId &&
+        areToolbarFramesEqual(currentRegistration.frame, frame)) {
+        return;
+    }
+    exports.editorToolbarFrames.set(id, { ownerId, frame });
+    notifyEditorToolbarFrameListeners();
+}
+function unregisterEditorToolbarFrame(id) {
+    if (exports.editorToolbarFrames.delete(id)) {
+        notifyEditorToolbarFrameListeners();
+    }
+}
+function preserveEditorToolbarFocusForNextBlur() {
+    exports.editorToolbarFocusPreserveUntil = Date.now() + exports.EDITOR_TOOLBAR_FOCUS_PRESERVE_MS;
+}
+function beginEditorToolbarInteraction() {
+    exports.activeEditorToolbarInteractions += 1;
+    preserveEditorToolbarFocusForNextBlur();
+}
+function endEditorToolbarInteraction() {
+    exports.activeEditorToolbarInteractions = Math.max(0, exports.activeEditorToolbarInteractions - 1);
+    preserveEditorToolbarFocusForNextBlur();
+}
+function isEditorToolbarFocusPreservationActive() {
+    return exports.activeEditorToolbarInteractions > 0 || Date.now() <= exports.editorToolbarFocusPreserveUntil;
+}
+function setActiveEditorToolbarFrameOwnerForEditor(ownerId, isActive) {
+    const nextOwnerId = isActive
+        ? ownerId
+        : exports.activeEditorToolbarFrameOwnerId === ownerId
+            ? null
+            : exports.activeEditorToolbarFrameOwnerId;
+    if (exports.activeEditorToolbarFrameOwnerId === nextOwnerId) {
+        return;
+    }
+    exports.activeEditorToolbarFrameOwnerId = nextOwnerId;
+    notifyEditorToolbarFrameListeners();
+}
+function useEditorToolbarFrames(ownerId) {
+    const [frames, setFrames] = (0, react_1.useState)(() => getEditorToolbarFramesSnapshot(ownerId));
+    (0, react_1.useEffect)(() => {
+        const listener = () => {
+            const nextFrames = getEditorToolbarFramesSnapshot(ownerId);
+            setFrames((currentFrames) => areToolbarFrameListsEqual(currentFrames, nextFrames) ? currentFrames : nextFrames);
+        };
+        exports.editorToolbarFrameListeners.add(listener);
+        listener();
+        return () => {
+            exports.editorToolbarFrameListeners.delete(listener);
+        };
+    }, [ownerId]);
+    return frames;
+}
+function setEditorToolbarMentionState(ownerId, state) {
+    if (state == null) {
+        if (exports.editorToolbarMentionState?.ownerId !== ownerId) {
+            return;
+        }
+        exports.editorToolbarMentionState = null;
+        notifyEditorToolbarMentionStateListeners();
+        return;
+    }
+    exports.editorToolbarMentionState = {
+        ownerId,
+        ...state,
+    };
+    notifyEditorToolbarMentionStateListeners();
+}
+function _setEditorToolbarFrameForTests(id, frame, ownerId = null) {
+    registerEditorToolbarFrame(id, frame, ownerId);
+}
+function _resetEditorToolbarFrameRegistryForTests() {
+    exports.editorToolbarFrames.clear();
+    exports.editorToolbarMentionState = null;
+    exports.activeEditorToolbarInteractions = 0;
+    exports.editorToolbarFocusPreserveUntil = 0;
+    exports.activeEditorToolbarFrameOwnerId = null;
+    notifyEditorToolbarFrameListeners();
+    notifyEditorToolbarMentionStateListeners();
+}
+function _beginEditorToolbarInteractionForTests() {
+    beginEditorToolbarInteraction();
+}
+function _endEditorToolbarInteractionForTests() {
+    endEditorToolbarInteraction();
+}
+exports.BUTTON_HIT = 44;