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

package/dist/AtomHost.js

@@ -40,8 +40,9 @@ const react_1 = __importStar(require("react"));
 const react_native_1 = require("react-native");
 const atomInstances_1 = require("./atomInstances");
 function atomIsVisible(y, height, viewport) {
-    if (!viewport)
+    if (!viewport) {
         return true;
+    }
     if (![viewport.y, viewport.height, viewport.overscan ?? 200].every(Number.isFinite) ||
         viewport.height < 0 ||
         (viewport.overscan ?? 200) < 0) {
@@ -64,8 +65,9 @@ class AtomErrorBoundary extends react_1.default.Component {
             : { component: props.component, error: false };
     }
     render() {
-        if (!this.state.error)
+        if (!this.state.error) {
             return this.props.children;
+        }
         return ((0, jsx_runtime_1.jsxs)(react_native_1.View, { accessibilityRole: 'alert', style: { minHeight: 32, padding: 8 }, children: [(0, jsx_runtime_1.jsxs)(react_native_1.Text, { children: ["Unable to display ", this.props.nodeType] }), (0, jsx_runtime_1.jsx)(react_native_1.Pressable, { accessibilityRole: 'button', onPress: () => this.setState({ error: false }), children: (0, jsx_runtime_1.jsx)(react_native_1.Text, { children: "Retry" }) })] }));
     }
 }
@@ -85,30 +87,35 @@ function AtomHost({ component: Component, atomProps, width, estimatedHeight, vis
         };
     }, []);
     const updateAttrs = (0, react_1.useCallback)(async (update) => {
-        if (!mounted.current)
+        if (!mounted.current) {
             throw new atomInstances_1.AtomUpdateAttrsError('not-ready', 'The atom is unmounted.');
+        }
         const request = ++latestRequest.current;
-        setPending((count) => count + 1);
+        setPending(count => count + 1);
         setUpdateError(null);
         try {
             await applyUpdate(update);
         }
         catch (error) {
-            if (mounted.current && latestRequest.current === request)
+            if (mounted.current && latestRequest.current === request) {
                 setUpdateError(error instanceof Error ? error : new Error(String(error)));
+            }
             throw error;
         }
         finally {
-            if (mounted.current)
-                setPending((count) => count - 1);
+            if (mounted.current) {
+                setPending(count => count - 1);
+            }
         }
     }, [applyUpdate]);
     const editor = (0, react_1.useMemo)(() => {
-        if (!atomProps.editor)
+        if (!atomProps.editor) {
             return undefined;
+        }
         const guard = (action) => async () => {
-            if (!mounted.current)
+            if (!mounted.current) {
                 throw new atomInstances_1.AtomUpdateAttrsError('not-ready', 'The atom is unmounted.');
+            }
             return action();
         };
         return {
@@ -120,14 +127,14 @@ function AtomHost({ component: Component, atomProps, width, estimatedHeight, vis
     }, [atomProps.editor]);
     const retainedHeight = measurement.width === width ? measurement.height : estimatedHeight;
     const show = visible || focused || active || pending > 0 || atomProps.selected;
-    return ((0, jsx_runtime_1.jsx)(react_native_1.View, { testID: 'atom-host', nativeID: nativeID, collapsable: false, pointerEvents: atomProps.interactive === false ? 'none' : 'box-none', accessibilityElementsHidden: !show, importantForAccessibility: !show ? 'no-hide-descendants' : 'auto', onFocus: () => setFocused(true), onBlur: () => setFocused(false), onLayout: (event) => {
+    return ((0, jsx_runtime_1.jsx)(react_native_1.View, { testID: 'atom-host', nativeID: nativeID, collapsable: false, pointerEvents: atomProps.interactive === false ? 'none' : 'box-none', accessibilityElementsHidden: !show, importantForAccessibility: !show ? 'no-hide-descendants' : 'auto', onFocus: () => setFocused(true), onBlur: () => setFocused(false), onLayout: event => {
             onMeasure?.(event);
             const size = event.nativeEvent.layout;
             if (show &&
                 Number.isFinite(size.height) &&
                 size.height >= 0 &&
                 Math.abs(size.width - width) <= 1) {
-                setMeasurement((previous) => previous.width === width && previous.height === size.height
+                setMeasurement(previous => previous.width === width && previous.height === size.height
                     ? previous
                     : { width, height: size.height });
             }

package/dist/EditorAddon.js

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMentionsAddon = createMentionsAddon;
 function copyConfiguration(value, ancestors = new Set()) {
-    if (value === null || typeof value !== 'object')
+    if (value === null || typeof value !== 'object') {
         return value;
-    if (ancestors.has(value))
+    }
+    if (ancestors.has(value)) {
         throw new Error('Addon configuration must not contain cycles.');
+    }
     if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype) {
         throw new Error('Addon configuration must contain only plain objects and arrays.');
     }

package/dist/EditorAddonNormalization.js

@@ -5,30 +5,38 @@ function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 function normalizeEditorAddons(addons) {
-    if (addons === undefined)
+    if (addons === undefined) {
         return {};
-    if (!Array.isArray(addons))
+    }
+    if (!Array.isArray(addons)) {
         throw new Error('addons must be a flat readonly array.');
+    }
     const normalized = {};
     const ids = new Set();
     for (const [index, addon] of addons.entries()) {
-        if (addon === false || addon === null || addon === undefined)
+        if (addon === false || addon === null || addon === undefined) {
             continue;
+        }
         const path = `addons[${index}]`;
-        if (!isRecord(addon))
+        if (!isRecord(addon)) {
             throw new Error(`${path} must be an addon descriptor.`);
-        if (addon.version !== 1)
+        }
+        if (addon.version !== 1) {
             throw new Error(`${path}.version must be 1.`);
+        }
         if (addon.capability !== 'mentions' && addon.capability !== 'code-highlighting') {
             throw new Error(`${path}.capability is unsupported.`);
         }
-        if (addon.id !== addon.capability)
+        if (addon.id !== addon.capability) {
             throw new Error(`${path}.id must match its capability.`);
-        if (ids.has(addon.capability))
-            throw new Error(`${path}: duplicate addon id '${addon.id}'.`);
+        }
+        if (ids.has(addon.capability)) {
+            throw new Error(`${path}: duplicate addon id '${String(addon.id)}'.`);
+        }
         ids.add(addon.capability);
-        if (!isRecord(addon.options))
+        if (!isRecord(addon.options)) {
             throw new Error(`${path}.options must be an object.`);
+        }
         if (addon.capability === 'mentions') {
             normalized.mentions = addon.options;
         }

package/dist/EditorMentionThemeNormalization.js

@@ -4,12 +4,15 @@ exports.normalizeEditorMentionTheme = normalizeEditorMentionTheme;
 const EditorStyleSheetNormalization_1 = require("./EditorStyleSheetNormalization");
 const EditorMentionThemeValidation_1 = require("./EditorMentionThemeValidation");
 function normalizeEditorMentionTheme(theme) {
-    if (theme === undefined)
+    if (theme === undefined) {
         return undefined;
-    if (!(0, EditorMentionThemeValidation_1.validEditorMentionTheme)(theme))
+    }
+    if (!(0, EditorMentionThemeValidation_1.validEditorMentionTheme)(theme)) {
         throw new TypeError('Invalid mention theme');
-    if (!theme.node)
+    }
+    if (!theme.node) {
         return theme;
+    }
     const node = theme.node;
     const { textColor, style: existingStyle, ...appearance } = node;
     const style = (0, EditorStyleSheetNormalization_1.normalizeEditorTheme)({

package/dist/EditorMentionThemeValidation.js

@@ -9,7 +9,7 @@ function isPlainRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 function hasOnlyOwnKeys(value, fields) {
-    return Reflect.ownKeys(value).every((key) => typeof key === 'string' && fields.includes(key));
+    return Reflect.ownKeys(value).every(key => typeof key === 'string' && fields.includes(key));
 }
 exports.MENTION_NODE_STRING_FIELDS = [
     'textColor',
@@ -41,7 +41,17 @@ exports.MENTION_SUGGESTIONS_NUMBER_FIELDS = [
     'borderWidth',
     'borderRadius',
 ];
-exports.EDITOR_MENTION_THEME_FONT_WEIGHTS = new Set(['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900']);
+exports.EDITOR_MENTION_THEME_FONT_WEIGHTS = new Set(['normal',
+    'bold',
+    '100',
+    '200',
+    '300',
+    '400',
+    '500',
+    '600',
+    '700',
+    '800',
+    '900']);
 exports.EDITOR_MENTION_THEME_FIELDS = [
     'node',
     'suggestions',
@@ -52,12 +62,14 @@ function validMentionFontWeight(value) {
             exports.EDITOR_MENTION_THEME_FONT_WEIGHTS.has(value)));
 }
 function validMentionThemeSection(value, stringFields, numberFields, extraFields) {
-    if (!isPlainRecord(value))
+    if (!isPlainRecord(value)) {
         return false;
-    if (!hasOnlyOwnKeys(value, [...stringFields, ...numberFields, ...extraFields]))
+    }
+    if (!hasOnlyOwnKeys(value, [...stringFields, ...numberFields, ...extraFields])) {
         return false;
-    return (stringFields.every((field) => value[field] === undefined || typeof value[field] === 'string') &&
-        numberFields.every((field) => value[field] === undefined ||
+    }
+    return (stringFields.every(field => value[field] === undefined || typeof value[field] === 'string') &&
+        numberFields.every(field => value[field] === undefined ||
             (typeof value[field] === 'number' && Number.isFinite(value[field]))));
 }
 function validEditorMentionTheme(value) {
@@ -66,16 +78,19 @@ function validEditorMentionTheme(value) {
     }
     const { node, suggestions } = value;
     if (node !== undefined) {
-        if (!isPlainRecord(node))
+        if (!isPlainRecord(node)) {
             return false;
+        }
         const { textColor, style, ...appearance } = node;
-        if (textColor !== undefined && typeof textColor !== 'string')
+        if (textColor !== undefined && typeof textColor !== 'string') {
             return false;
+        }
         try {
             (0, EditorStyleSheetNormalization_1.normalizeEditorTheme)({ mention: [{ color: textColor }, appearance] });
             if (style !== undefined) {
-                if (!isPlainRecord(style))
+                if (!isPlainRecord(style)) {
                     return false;
+                }
                 (0, EditorStyleSheetNormalization_1.normalizeEditorTheme)({ mention: style });
             }
         }
@@ -83,13 +98,15 @@ function validEditorMentionTheme(value) {
             return false;
         }
     }
-    if (suggestions === undefined)
+    if (suggestions === undefined) {
         return true;
+    }
     if (!validMentionThemeSection(suggestions, exports.MENTION_SUGGESTIONS_STRING_FIELDS, exports.MENTION_SUGGESTIONS_NUMBER_FIELDS, ['option'])) {
         return false;
     }
     const option = suggestions.option;
-    if (option === undefined)
+    if (option === undefined) {
         return true;
+    }
     return (validMentionThemeSection(option, exports.MENTION_OPTION_STRING_FIELDS, exports.MENTION_OPTION_NUMBER_FIELDS, ['fontWeight']) && validMentionFontWeight(option.fontWeight));
 }

package/dist/EditorStyleSheetNormalization.js

@@ -22,14 +22,14 @@ const border = [
     'borderColor',
     'borderStyle',
     'borderRadius',
-    ...sides.flatMap((side) => [`border${side}Width`, `border${side}Color`]),
-    ...corners.map((corner) => `border${corner}Radius`),
+    ...sides.flatMap(side => [`border${side}Width`, `border${side}Color`]),
+    ...corners.map(corner => `border${corner}Radius`),
 ];
 const spacing = (prefix) => [
     prefix,
     `${prefix}Horizontal`,
     `${prefix}Vertical`,
-    ...sides.map((side) => `${prefix}${side}`),
+    ...sides.map(side => `${prefix}${side}`),
 ];
 const surface = ['backgroundColor', ...border, ...spacing('padding')];
 const box = [...surface, ...spacing('margin')];
@@ -63,13 +63,27 @@ const fields = {
     italic: inline,
     underline: inline,
     strike: inline,
-    mention: [...inline, ...border],
+    mention: [...inline, ...border, ...spacing('padding')],
     placeholder: typography,
 };
 const enums = {
     fontStyle: ['normal', 'italic'],
-    fontWeight: ['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900'],
-    textAlign: ['auto', 'left', 'right', 'center', 'justify'],
+    fontWeight: ['normal',
+        'bold',
+        '100',
+        '200',
+        '300',
+        '400',
+        '500',
+        '600',
+        '700',
+        '800',
+        '900'],
+    textAlign: ['auto',
+        'left',
+        'right',
+        'center',
+        'justify'],
     textDecorationLine: ['none', 'underline', 'line-through', 'underline line-through'],
     textDecorationStyle: ['solid', 'double', 'dotted', 'dashed'],
     borderStyle: ['solid', 'dashed', 'dotted'],
@@ -79,39 +93,50 @@ function invalid(path, reason) {
     throw new TypeError(`Invalid editor style ${path}: ${reason}`);
 }
 function record(value) {
-    if (value == null || typeof value !== 'object' || Array.isArray(value))
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
         return false;
+    }
     const prototype = Object.getPrototypeOf(value);
     return prototype === Object.prototype || prototype === null;
 }
 function normalizeEditorColor(value, path) {
-    if (typeof value !== 'string')
+    if (typeof value !== 'string') {
         return invalid(path, 'expected a color string');
+    }
     const argb = (0, react_native_1.processColor)(value);
-    if (typeof argb !== 'number')
+    if (typeof argb !== 'number') {
         return invalid(path, 'unrecognized color');
+    }
     const rgba = ((argb << 8) | (argb >>> 24)) >>> 0;
     return `#${rgba.toString(16).padStart(8, '0')}`;
 }
 function orderedMarker(value, path) {
-    if (!record(value))
+    if (!record(value)) {
         return invalid(path, 'expected an ordered marker object');
+    }
     const result = {};
     for (const [key, entry] of Object.entries(value)) {
-        if (key !== 'schemes' && key !== 'suffix')
+        if (key !== 'schemes' && key !== 'suffix') {
             invalid(`${path}.${key}`, 'unsupported property');
-        if (entry === undefined)
+        }
+        if (entry === undefined) {
             continue;
+        }
         if (key === 'suffix') {
-            if (entry !== '.' && entry !== ')')
+            if (entry !== '.' && entry !== ')') {
                 invalid(`${path}.${key}`, 'expected . or )');
+            }
             result[key] = entry;
         }
         else {
-            const schemes = ['decimal', 'lowerAlpha', 'upperAlpha', 'lowerRoman', 'upperRoman'];
+            const schemes = ['decimal',
+                'lowerAlpha',
+                'upperAlpha',
+                'lowerRoman',
+                'upperRoman'];
             if (!Array.isArray(entry) ||
                 entry.length === 0 ||
-                !entry.every((item) => typeof item === 'string' && schemes.includes(item))) {
+                !entry.every(item => typeof item === 'string' && schemes.includes(item))) {
                 invalid(`${path}.${key}`, 'expected a nonempty array of numbering schemes');
             }
             result[key] = [...entry];
@@ -120,54 +145,68 @@ function orderedMarker(value, path) {
     return result;
 }
 function property(key, value, path) {
-    if (value === undefined)
+    if (value === undefined) {
         return undefined;
-    if (key === 'ordered')
+    }
+    if (key === 'ordered') {
         return orderedMarker(value, path);
-    if (key === 'checked')
+    }
+    if (key === 'checked') {
         return normalizeStyle(value, checkbox, path);
-    if (key === 'color' || key.endsWith('Color'))
+    }
+    if (key === 'color' || key.endsWith('Color')) {
         return normalizeEditorColor(value, path);
+    }
     if (key === 'fontFamily') {
-        if (typeof value !== 'string' || value.length === 0)
+        if (typeof value !== 'string' || value.length === 0) {
             invalid(path, 'expected a nonempty font family');
+        }
         return value;
     }
     if (enums[key]) {
         const candidate = key === 'fontWeight' && typeof value === 'number' ? String(value) : value;
-        if (typeof candidate !== 'string' || !enums[key].includes(candidate))
+        if (typeof candidate !== 'string' || !enums[key].includes(candidate)) {
             invalid(path, 'unsupported value');
+        }
         return candidate;
     }
-    if (typeof value !== 'number' || !Number.isFinite(value))
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
         invalid(path, 'expected a finite number');
-    if (['fontSize', 'lineHeight', 'size', 'scale'].includes(key) && value <= 0)
+    }
+    if (['fontSize', 'lineHeight', 'size', 'scale'].includes(key) && value <= 0) {
         invalid(path, 'expected a positive number');
-    if (!key.startsWith('margin') && key !== 'letterSpacing' && value < 0)
+    }
+    if (!key.startsWith('margin') && key !== 'letterSpacing' && value < 0) {
         invalid(path, 'expected a nonnegative number');
+    }
     return value;
 }
 function normalizeStyle(value, allowed, path) {
     const raw = {};
     const ancestors = new Set();
     function append(entry, depth) {
-        if (entry === false || entry == null)
+        if (entry === false || entry == null) {
             return;
-        if (depth > 64)
+        }
+        if (depth > 64) {
             invalid(path, 'style arrays are nested too deeply');
+        }
         if (Array.isArray(entry)) {
-            if (ancestors.has(entry))
+            if (ancestors.has(entry)) {
                 invalid(path, 'cyclic style array');
+            }
             ancestors.add(entry);
-            entry.forEach((item) => append(item, depth + 1));
+            entry.forEach(item => append(item, depth + 1));
             ancestors.delete(entry);
             return;
         }
-        if (!record(entry))
+        if (!record(entry)) {
             invalid(path, 'expected a style object or array');
+        }
         for (const [key, field] of Object.entries(entry)) {
-            if (!allowed.includes(key))
+            if (!allowed.includes(key)) {
                 invalid(`${path}.${key}`, 'unsupported property');
+            }
             raw[key] = property(key, field, `${path}.${key}`);
         }
     }
@@ -177,8 +216,9 @@ function normalizeStyle(value, allowed, path) {
         for (const side of sides) {
             const axis = side === 'Top' || side === 'Bottom' ? 'Vertical' : 'Horizontal';
             const resolved = raw[`${prefix}${side}`] ?? raw[`${prefix}${axis}`] ?? raw[prefix];
-            if (resolved !== undefined)
+            if (resolved !== undefined) {
                 result[`${prefix}${side}`] = resolved;
+            }
         }
         delete result[prefix];
         delete result[`${prefix}Horizontal`];
@@ -187,40 +227,47 @@ function normalizeStyle(value, allowed, path) {
     for (const suffix of ['Width', 'Color']) {
         for (const side of sides) {
             const resolved = raw[`border${side}${suffix}`] ?? raw[`border${suffix}`];
-            if (resolved !== undefined)
+            if (resolved !== undefined) {
                 result[`border${side}${suffix}`] = resolved;
+            }
         }
         delete result[`border${suffix}`];
     }
     for (const corner of corners) {
         const resolved = raw[`border${corner}Radius`] ?? raw.borderRadius;
-        if (resolved !== undefined)
+        if (resolved !== undefined) {
             result[`border${corner}Radius`] = resolved;
+        }
     }
     delete result.borderRadius;
     return result;
 }
 function normalizeEditorTheme(theme) {
-    if (!record(theme))
+    if (!record(theme)) {
         invalid('theme', 'expected a named style map');
+    }
     const styles = {};
     const result = { version: 1 };
     for (const [key, value] of Object.entries(theme)) {
         if (key === 'toolbar') {
             if (value !== undefined) {
-                if (!record(value))
+                if (!record(value)) {
                     invalid('toolbar', 'expected toolbar configuration');
+                }
                 result.toolbar = { ...value };
             }
             continue;
         }
-        if (!Object.prototype.hasOwnProperty.call(fields, key))
+        if (!Object.prototype.hasOwnProperty.call(fields, key)) {
             invalid(key, 'unsupported element');
+        }
         const style = normalizeStyle(value, fields[key], key);
-        if (Object.keys(style).length)
+        if (Object.keys(style).length) {
             styles[key] = style;
+        }
     }
-    if (Object.keys(styles).length)
+    if (Object.keys(styles).length) {
         result.styles = styles;
+    }
     return result;
 }

package/dist/EditorStyleSheetTypes.d.ts

@@ -91,7 +91,7 @@ export interface EditorHorizontalRuleStyle extends EditorBorderStyle, EditorMarg
     backgroundColor?: string;
     height?: number;
 }
-export interface EditorMentionStyle extends EditorInlineStyle, EditorBorderStyle {
+export interface EditorMentionStyle extends EditorInlineStyle, EditorBorderStyle, EditorPaddingStyle {
 }
 export interface EditorStyleMap {
     content: EditorSurfaceStyle;

package/dist/EditorTheme.d.ts

@@ -114,4 +114,8 @@ export interface EditorContentInsets {
     bottom?: number;
     left?: number;
 }
+/**
+ * Mentions are configured on the mentions addon, not on EditorTheme; native
+ * still reads them from the theme payload.
+ */
 export declare function serializeEditorTheme(theme?: EditorTheme, mentionTheme?: EditorMentionTheme): string | undefined;

package/dist/EditorTheme.js

@@ -5,7 +5,7 @@ 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);
+        return value.map(item => stripUndefined(item)).filter(item => item !== undefined);
     }
     if (value != null && typeof value === 'object') {
         const entries = Object.entries(value)
@@ -21,8 +21,10 @@ function stripUndefined(value) {
     }
     return value;
 }
-// Mentions are configured on the mentions addon, not on EditorTheme; native
-// still reads them from the theme payload.
+/**
+ * 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)

package/dist/EditorToolbarComponent.d.ts

@@ -1,7 +1,7 @@
 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
+ * 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.

package/dist/EditorToolbarComponent.js

@@ -7,7 +7,7 @@ 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
+ * 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.

package/dist/EditorToolbarRegistry.js

@@ -55,16 +55,16 @@ function areToolbarFrameListsEqual(left, right) {
     return left.every((frame, index) => areToolbarFramesEqual(frame, right[index]));
 }
 function notifyEditorToolbarFrameListeners() {
-    exports.editorToolbarFrameListeners.forEach((listener) => listener());
+    exports.editorToolbarFrameListeners.forEach(listener => listener());
 }
 function notifyEditorToolbarMentionStateListeners() {
-    exports.editorToolbarMentionStateListeners.forEach((listener) => listener());
+    exports.editorToolbarMentionStateListeners.forEach(listener => listener());
 }
 function getEditorToolbarFramesSnapshot(ownerId) {
     return Array.from(exports.editorToolbarFrames.values())
-        .filter((registration) => registration.ownerId === ownerId ||
+        .filter(registration => registration.ownerId === ownerId ||
         (registration.ownerId == null && exports.activeEditorToolbarFrameOwnerId === ownerId))
-        .map((registration) => registration.frame);
+        .map(registration => registration.frame);
 }
 function subscribeEditorToolbarMentionState(listener) {
     exports.editorToolbarMentionStateListeners.add(listener);
@@ -129,7 +129,7 @@ function useEditorToolbarFrames(ownerId) {
     (0, react_1.useEffect)(() => {
         const listener = () => {
             const nextFrames = getEditorToolbarFramesSnapshot(ownerId);
-            setFrames((currentFrames) => areToolbarFrameListsEqual(currentFrames, nextFrames) ? currentFrames : nextFrames);
+            setFrames(currentFrames => areToolbarFrameListsEqual(currentFrames, nextFrames) ? currentFrames : nextFrames);
         };
         exports.editorToolbarFrameListeners.add(listener);
         listener();

package/dist/EditorToolbarTypes.d.ts

@@ -34,9 +34,9 @@ export interface EditorToolbarMaterialIcon {
 /**
  * A toolbar button's icon:
  *
- * - `default` — one of the package's built-in icons.
- * - `glyph` — arbitrary text or an emoji, drawn as-is.
- * - `platform` — per-platform native icons, with `fallbackText` when the
+ * - `default` : one of the package's built-in icons.
+ * - `glyph` : arbitrary text or an emoji, drawn as-is.
+ * - `platform` : per-platform native icons, with `fallbackText` when the
  *   platform cannot resolve the named icon.
  */
 export type EditorToolbarIcon = {
@@ -67,14 +67,14 @@ export interface EditorToolbarButtonStyle {
  * name), an `icon`, an optional `key` (defaults to something derived from the
  * variant), and an optional `placement`.
  *
- * - `mark` — toggles the named mark; active and enabled state come from the engine.
- * - `link` / `image` — calls the editor's `onRequestLink` / `onRequestImage`.
- * - `heading` — toggles the given heading level.
- * - `blockquote` — toggles blockquote wrapping.
- * - `list` — toggles the given list type.
- * - `command` — runs an {@link EditorToolbarCommand}.
- * - `node` — inserts the named node type, e.g. `'horizontalRule'`.
- * - `action` — host-defined; calls `onToolbarAction` with its `key`, and the
+ * - `mark` : toggles the named mark; active and enabled state come from the engine.
+ * - `link` / `image` : calls the editor's `onRequestLink` / `onRequestImage`.
+ * - `heading` : toggles the given heading level.
+ * - `blockquote` : toggles blockquote wrapping.
+ * - `list` : toggles the given list type.
+ * - `command` : runs an {@link EditorToolbarCommand}.
+ * - `node` : inserts the named node type, e.g. `'horizontalRule'`.
+ * - `action` : host-defined; calls `onToolbarAction` with its `key`, and the
  *   host supplies `isActive`/`isDisabled` since the engine knows nothing about it.
  */
 export type EditorToolbarLeafItem = ({
@@ -144,7 +144,7 @@ export type EditorToolbarLeafItem = ({
 /** What a group may contain. Groups do not nest. */
 export type EditorToolbarGroupChildItem = EditorToolbarLeafItem;
 /**
- * Several buttons collapsed behind one — heading levels, say. The group
+ * Several buttons collapsed behind one : heading levels, say. The group
  * reports active when any child is active, and disabled when every child is.
  */
 export interface EditorToolbarGroupItem {

package/dist/EditorToolbarVisuals.js

@@ -47,7 +47,7 @@ exports.DEFAULT_GLYPH_ICONS = {
     indentList: '→',
     outdentList: '←',
     lineBreak: '↵',
-    horizontalRule: '—',
+    horizontalRule: ':',
     undo: '↩',
     redo: '↪',
 };