@inshapardaz/likhari-react 0.1.28-dev.245 → 0.1.28-dev.257

package/dist/components/Toolbar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Toolbar.d.ts","sourceRoot":"","sources":["../../src/components/Toolbar.tsx"],"names":[],"mappings":"AA0CA,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnF,OAAO,EAA2B,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAgDtF,OAAO,EAAgB,KAAK,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAEzE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AAC7E,OAAO,EAA6D,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAItG,OAAO,KAAK,EAAE,MAAM,EAAW,MAAM,iBAAiB,CAAC;AA+hBvD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,2BAA2B,CAAC;IACpC,gCAAgC;IAChC,eAAe,CAAC,EAAE,cAAc,EAAE,CAAC;IACnC,qDAAqD;IACrD,gBAAgB,CAAC,EAAE,aAAa,EAAE,CAAC;IACnC,4DAA4D;IAC5D,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAC;IACnE,+FAA+F;IAC/F,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,wFAAwF;IACxF,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,IAAI,CAAC;IAC3B,iGAAiG;IACjG,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,mBAAmB,CAAC,EAAE,MAAM,IAAI,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,sEAAsE;IACtE,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,wFAAwF;IACxF,SAAS,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IAC1B,oFAAoF;IACpF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kGAAkG;IAClG,MAAM,CAAC,EAAE,oBAAoB,CAAC;CAC/B;AAED,wBAAgB,OAAO,CAAC,EAAE,MAAM,EAAE,gBAAqB,EAAE,eAAoB,EAAE,gBAAgB,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAgB,EAAE,YAAY,EAAE,SAAiB,EAAE,aAAa,EAAE,eAAuB,EAAE,mBAAmB,EAAE,WAAkC,EAAE,SAAiB,EAAE,MAAa,EAAE,MAAM,EAAE,EAAE,YAAY,+BAspCvU"}
+{"version":3,"file":"Toolbar.d.ts","sourceRoot":"","sources":["../../src/components/Toolbar.tsx"],"names":[],"mappings":"AA0CA,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnF,OAAO,EAA2B,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAgDtF,OAAO,EAAgB,KAAK,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAEzE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AAC7E,OAAO,EAA6D,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAItG,OAAO,KAAK,EAAE,MAAM,EAAW,MAAM,iBAAiB,CAAC;AAggBvD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,2BAA2B,CAAC;IACpC,gCAAgC;IAChC,eAAe,CAAC,EAAE,cAAc,EAAE,CAAC;IACnC,qDAAqD;IACrD,gBAAgB,CAAC,EAAE,aAAa,EAAE,CAAC;IACnC,4DAA4D;IAC5D,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAC;IACnE,+FAA+F;IAC/F,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,wFAAwF;IACxF,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,IAAI,CAAC;IAC3B,iGAAiG;IACjG,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,mBAAmB,CAAC,EAAE,MAAM,IAAI,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,sEAAsE;IACtE,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,wFAAwF;IACxF,SAAS,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IAC1B,oFAAoF;IACpF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kGAAkG;IAClG,MAAM,CAAC,EAAE,oBAAoB,CAAC;CAC/B;AAED,wBAAgB,OAAO,CAAC,EAAE,MAAM,EAAE,gBAAqB,EAAE,eAAoB,EAAE,gBAAgB,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAgB,EAAE,YAAY,EAAE,SAAiB,EAAE,aAAa,EAAE,eAAuB,EAAE,mBAAmB,EAAE,WAAkC,EAAE,SAAiB,EAAE,MAAa,EAAE,MAAM,EAAE,EAAE,YAAY,+BA+/BvU"}

package/dist/components/Toolbar.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
-import { Menu, Select } from '@mantine/core';
+import { Fragment, forwardRef, useCallback, useEffect, useRef, useState } from 'react';
+import { Menu, Select, Toolbar as MantineToolbar } from '@mantine/core';
 import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
 import { $getSelection, $isRangeSelection, $isElementNode, $setSelection, $getRoot, $selectAll, $getNearestNodeFromDOMNode, $createTextNode, KEY_MODIFIER_COMMAND, COMMAND_PRIORITY_NORMAL, FORMAT_TEXT_COMMAND, FORMAT_ELEMENT_COMMAND, INDENT_CONTENT_COMMAND, OUTDENT_CONTENT_COMMAND, UNDO_COMMAND, REDO_COMMAND, SELECTION_CHANGE_COMMAND, CAN_UNDO_COMMAND, CAN_REDO_COMMAND, COMMAND_PRIORITY_LOW, } from 'lexical';
 import { $getSelectionStyleValueForProperty, $patchStyleText, $setBlocksType } from '@lexical/selection';
@@ -108,15 +108,18 @@ function iconOptionRenderer(icons, fallback) {
         return (_jsxs("span", { style: { display: 'flex', alignItems: 'center', gap: 8 }, children: [_jsx(Icon, { size: 16, stroke: ICON_STROKE }), option.label] }));
     };
 }
-function ToolbarButton({ icon: Icon, title, active, dirty, disabled, onClick, }) {
-    return (_jsx("button", { type: "button", className: "likhari-toolbar-button", "data-active": active ? 'true' : 'false', "data-dirty": dirty === undefined ? undefined : dirty ? 'true' : 'false', disabled: disabled, "aria-pressed": active, "aria-label": title, title: title, onMouseDown: (e) => e.preventDefault(), onClick: onClick, children: _jsx(Icon, { size: ICON_SIZE, stroke: ICON_STROKE }) }));
-}
-/** A disabled placeholder for a feature whose config flag is on but that
- * isn't implemented yet (link/image/poetry/font/language-tooling — see
- * docs/lexical-editor-spec.md §13's phasing). Renders so the toolbar's
- * layout is final now and only needs its onClick wired up later. */
-function StubButton({ icon, title, comingSoon }) {
-    return _jsx(ToolbarButton, { icon: icon, title: comingSoon(title), disabled: true, onClick: undefined });
+const ToolbarButton = forwardRef(function ToolbarButton({ icon: Icon, title, active, dirty, onMouseDown, ...rest }, ref) {
+    return (_jsx(MantineToolbar.Toggle, { ref: ref, "aria-label": title, title: title, active: active, "data-dirty": dirty === undefined ? undefined : dirty ? 'true' : 'false', 
+        // Keep the editor's selection: a mousedown here would blur the canvas.
+        onMouseDown: (e) => {
+            e.preventDefault();
+            onMouseDown?.(e);
+        }, ...rest, children: _jsx(Icon, { size: ICON_SIZE, stroke: ICON_STROKE }) }));
+});
+function withDividers(sections) {
+    return sections
+        .filter((section) => Boolean(section))
+        .flatMap((section, index) => (index === 0 ? [section] : [_jsx(MantineToolbar.Divider, {}, `divider-${index}`), section]));
 }
 /** Mantine Select (combobox) for the toolbar's dropdown controls. The icon
  * labels the control itself, since a dropdown can't show one per option in
@@ -126,24 +129,9 @@ function ToolbarSelect({ icon: Icon, label, value, data, width, disabled, placeh
     const portalTarget = usePortalTarget();
     return (_jsx(Select, { size: "xs", w: width, "aria-label": label, title: disabled && comingSoon ? comingSoon(label) : label, data: data, value: value, placeholder: placeholder, disabled: disabled, searchable: searchable, renderOption: renderOption, nothingFoundMessage: searchable ? noMatchMessage : undefined, allowDeselect: false, leftSection: _jsx(Icon, { size: 15, stroke: ICON_STROKE }), comboboxProps: { withinPortal: true, position: 'bottom-start', middlewares: { flip: true, shift: true }, portalProps: { target: portalTarget } }, classNames: { input: 'likhari-toolbar-select-input', dropdown: 'likhari-toolbar-select-dropdown' }, onChange: (v) => v && onChange?.(v) }));
 }
-const EMPTY_OVERFLOW = new Set();
-function setsEqual(a, b) {
-    if (a.size !== b.size)
-        return false;
-    for (const v of a)
-        if (!b.has(v))
-            return false;
-    return true;
-}
-/** Renders a movable group's items as normal inline toolbar buttons (used
- * both in the real toolbar and in the hidden width-measuring clone). */
-function MovableGroupButtons({ group }) {
-    return (_jsx("div", { className: "likhari-toolbar-group", "data-group-key": group.key, children: group.items.map((item) => (_jsx(ToolbarButton, { icon: item.icon, title: item.label, active: item.active, onClick: item.onClick }, item.key))) }));
-}
-function OverflowItem({ icon: Icon, label, active, onClick, }) {
-    return (_jsx(Menu.Item, { leftSection: _jsx(Icon, { size: ICON_SIZE, stroke: ICON_STROKE }), "data-active": active ? 'true' : 'false', className: "likhari-overflow-item", 
-        // Keep the editor's selection: a mousedown here would blur the canvas.
-        onMouseDown: (e) => e.preventDefault(), onClick: onClick, children: label }));
+/** An item in the "..." menu. A mousedown here would blur the canvas, so it is kept. */
+function MoreMenuItem({ icon: Icon, label, active, onClick, }) {
+    return (_jsx(Menu.Item, { leftSection: _jsx(Icon, { size: ICON_SIZE, stroke: ICON_STROKE }), "data-active": active ? 'true' : 'false', onMouseDown: (e) => e.preventDefault(), onClick: onClick, children: label }));
 }
 function LinkMenuItems({ url, onEdit, onRemove, strings }) {
     // Only offer the link as clickable if it's a URL the editor would have accepted.
@@ -194,15 +182,6 @@ export function Toolbar({ config, dictionaryStores = [], thesaurusStores = [], o
     const [draftsOpen, setDraftsOpen] = useState(false);
     const rtl = direction === 'rtl';
     const ALIGN_ICONS = rtl ? ALIGN_ICONS_RTL : ALIGN_ICONS_LTR;
-    // Responsive "priority+" overflow: the toolbar's outer container and a
-    // hidden nowrap clone (rendered with every movable group forced inline)
-    // are both measured; whenever the clone's natural width exceeds the
-    // container's available width, the lowest-priority movable groups are
-    // moved into the "..." menu, lowest-priority first, until what remains
-    // inline fits (or there's nothing left to move).
-    const toolbarContainerRef = useRef(null);
-    const toolbarMeasureRef = useRef(null);
-    const [overflowGroupKeys, setOverflowGroupKeys] = useState(EMPTY_OVERFLOW);
     const updateToolbar = useCallback(() => {
         editor.getEditorState().read(() => {
             const selection = $getSelection();
@@ -342,7 +321,7 @@ export function Toolbar({ config, dictionaryStores = [], thesaurusStores = [], o
     };
     const snapshotSelectionRef = useRef(snapshotSelection);
     snapshotSelectionRef.current = snapshotSelection;
-    const runOverflowAction = (action) => () => {
+    const runMenuItem = (action) => () => {
         const saved = menuSelectionRef.current;
         if (saved)
             editor.update(() => $setSelection(saved.clone()), { discrete: true });
@@ -646,35 +625,22 @@ export function Toolbar({ config, dictionaryStores = [], thesaurusStores = [], o
     const headingLevels = config.blocks.headingLevels ?? [];
     const fmt = config.formatting;
     const showFormattingGroup = headingLevels.length > 0 || config.lists.bullet || config.lists.numbered || config.lists.check || config.blocks.quote;
-    const showInlineGroup = fmt.bold || fmt.italic || fmt.underline;
     const showAlignGroup = config.alignment.start || config.alignment.center || config.alignment.justify || config.alignment.left || config.alignment.right;
-    const showStubInsertGroup = config.images.linked ||
+    const showInsertGroup = config.links ||
+        config.images.linked ||
         config.images.embedded ||
         config.tables ||
         config.blocks.horizontalRule ||
         config.blocks.pageBreak ||
         config.columns ||
         config.footnotes ||
-        config.poetry.enabled;
+        (config.poetry.enabled && locale !== 'en') ||
+        (config.tables && state.inTable) ||
+        (config.poetry.enabled && state.inPoetry);
     const showLanguageGroup = config.language.autocorrect || config.language.textCleanup || config.language.spellCheck;
-    // The "script & cleanup" and "indent/outdent" groups (UI spec §3.3) render
-    // as normal inline toolbar groups whenever there's room, and only move
-    // into the "..." overflow menu when the measured toolbar content doesn't
-    // fit the available width (see the ResizeObserver effect below) — this
-    // replaces the old always-on overflow menu, which was driven purely by
-    // these config flags regardless of actual space.
-    const scriptCleanupItems = [];
-    if (fmt.strikethrough) {
-        scriptCleanupItems.push({
-            key: 'strikethrough',
-            icon: IconStrikethrough,
-            label: strings.toolbar.strikethrough,
-            active: state.activeFormats.has('strikethrough'),
-            onClick: () => formatText('strikethrough'),
-        });
-    }
+    const moreItems = [];
     if (fmt.superscript) {
-        scriptCleanupItems.push({
+        moreItems.push({
             key: 'superscript',
             icon: IconSuperscript,
             label: strings.toolbar.superscript,
@@ -683,7 +649,7 @@ export function Toolbar({ config, dictionaryStores = [], thesaurusStores = [], o
         });
     }
     if (fmt.subscript) {
-        scriptCleanupItems.push({
+        moreItems.push({
             key: 'subscript',
             icon: IconSubscript,
             label: strings.toolbar.subscript,
@@ -692,10 +658,10 @@ export function Toolbar({ config, dictionaryStores = [], thesaurusStores = [], o
         });
     }
     if (fmt.caseTransforms) {
-        scriptCleanupItems.push({ key: 'upper', icon: IconLetterCaseUpper, label: strings.toolbar.uppercase, onClick: () => applyCaseTransform('upper') }, { key: 'lower', icon: IconLetterCaseLower, label: strings.toolbar.lowercase, onClick: () => applyCaseTransform('lower') }, { key: 'capitalize', icon: IconLetterCase, label: strings.toolbar.capitalize, onClick: () => applyCaseTransform('capitalize') });
+        moreItems.push({ key: 'upper', icon: IconLetterCaseUpper, label: strings.toolbar.uppercase, onClick: () => applyCaseTransform('upper') }, { key: 'lower', icon: IconLetterCaseLower, label: strings.toolbar.lowercase, onClick: () => applyCaseTransform('lower') }, { key: 'capitalize', icon: IconLetterCase, label: strings.toolbar.capitalize, onClick: () => applyCaseTransform('capitalize') });
     }
     if (fmt.clearFormatting) {
-        scriptCleanupItems.push({ key: 'clear', icon: IconClearFormatting, label: strings.toolbar.clearFormatting, onClick: clearFormatting });
+        moreItems.push({ key: 'clear', icon: IconClearFormatting, label: strings.toolbar.clearFormatting, onClick: clearFormatting });
     }
     // UI spec §5: indent/outdent arrows are direction-relative and swap in RTL
     // (outdent moves content toward the start edge, which is the right in RTL).
@@ -715,56 +681,6 @@ export function Toolbar({ config, dictionaryStores = [], thesaurusStores = [], o
             },
         ]
         : [];
-    // Low to high priority: the first group here is the first one pushed into
-    // overflow once content stops fitting (UI spec §3.3).
-    const movableGroups = [
-        { key: 'scriptCleanup', items: scriptCleanupItems },
-        { key: 'indentOutdent', items: indentItems },
-    ].filter((g) => g.items.length > 0);
-    const movableGroupKeys = useMemo(() => movableGroups.map((g) => g.key).join(','), [movableGroups]);
-    // Re-measure whenever the container is resized, or whenever the set of
-    // movable groups (and so the hidden clone's content) changes.
-    useLayoutEffect(() => {
-        const container = toolbarContainerRef.current;
-        const measure = toolbarMeasureRef.current;
-        if (!container || !measure)
-            return;
-        // Rough width of the "..." button itself (icon button + its gap) —
-        // only charged against the budget once something has actually moved
-        // into it, since it isn't rendered at all otherwise.
-        const OVERFLOW_BUTTON_WIDTH = 38;
-        const recompute = () => {
-            const available = container.clientWidth;
-            const total = measure.scrollWidth;
-            if (total <= available) {
-                setOverflowGroupKeys((prev) => (prev.size === 0 ? prev : EMPTY_OVERFLOW));
-                return;
-            }
-            const widths = new Map();
-            measure.querySelectorAll('[data-group-key]').forEach((el) => {
-                widths.set(el.dataset.groupKey, el.getBoundingClientRect().width);
-            });
-            let remaining = total;
-            const next = new Set();
-            for (const key of movableGroupKeys.split(',').filter(Boolean)) {
-                if (remaining <= available)
-                    break;
-                const w = widths.get(key);
-                if (w === undefined)
-                    continue;
-                remaining -= w;
-                next.add(key);
-            }
-            if (next.size > 0)
-                remaining += OVERFLOW_BUTTON_WIDTH;
-            setOverflowGroupKeys((prev) => (setsEqual(prev, next) ? prev : next));
-        };
-        recompute();
-        const ro = new ResizeObserver(recompute);
-        ro.observe(container);
-        ro.observe(measure);
-        return () => ro.disconnect();
-    });
     // Grouped for the dropdown when options declare groups (Latin / Urdu).
     const fontData = (() => {
         const data = [];
@@ -807,36 +723,26 @@ export function Toolbar({ config, dictionaryStores = [], thesaurusStores = [], o
     ];
     const formattingValue = state.listType ?? state.blockType;
     const AlignIcon = ALIGN_ICONS[state.elementFormat] ?? IconAlignLeft;
-    // The toolbar's "always inline" groups (UI spec §3.3's Desktop tier) —
-    // built as an array so the exact same elements can be rendered both in
-    // the visible toolbar and in the hidden width-measuring clone below,
-    // without duplicating the JSX. The link right-click context menu is kept
-    // out of this list: it's a zero-size, fixed-position anchor, not part of
-    // the toolbar's own layout width.
-    const fixedGroups = [
-        showSave && (_jsx("div", { className: "likhari-toolbar-group", children: _jsx(ToolbarButton, { icon: IconDeviceFloppy, title: strings.toolbar.save, dirty: Boolean(isDirty), onClick: onSave }) }, "save")),
-        drafts && (_jsx("div", { className: "likhari-toolbar-group", children: _jsx(ToolbarButton, { icon: IconHistory, title: strings.toolbar.drafts, onClick: () => setDraftsOpen(true) }) }, "drafts")),
-        config.history && (_jsxs("div", { className: "likhari-toolbar-group", children: [_jsx(ToolbarButton, { icon: IconArrowBackUp, title: strings.toolbar.undo, disabled: !state.canUndo, onClick: () => editor.dispatchCommand(UNDO_COMMAND, undefined) }), _jsx(ToolbarButton, { icon: IconArrowForwardUp, title: strings.toolbar.redo, disabled: !state.canRedo, onClick: () => editor.dispatchCommand(REDO_COMMAND, undefined) })] }, "history")),
-        showFormattingGroup && (_jsx("div", { className: "likhari-toolbar-group", children: _jsx(ToolbarSelect, { icon: IconPilcrow, label: strings.toolbar.formattingLabel, width: 148, value: formattingValue, data: formattingOptions, comingSoon: strings.toolbar.comingSoon, renderOption: iconOptionRenderer(FORMATTING_ICONS, IconPilcrow), onChange: withRefocus((v) => applyFormatting(v)) }) }, "formatting")),
-        showInlineGroup && (_jsxs("div", { className: "likhari-toolbar-group", children: [fmt.bold && (_jsx(ToolbarButton, { icon: IconBold, title: strings.toolbar.bold, active: state.activeFormats.has('bold'), onClick: () => formatText('bold') })), fmt.italic && (_jsx(ToolbarButton, { icon: IconItalic, title: strings.toolbar.italic, active: state.activeFormats.has('italic'), onClick: () => formatText('italic') })), fmt.underline && (_jsx(ToolbarButton, { icon: IconUnderline, title: strings.toolbar.underline, active: state.activeFormats.has('underline'), onClick: () => formatText('underline') }))] }, "inline")),
-        (config.font.family || config.font.size) && (_jsxs("div", { className: "likhari-toolbar-group", children: [config.font.family && (_jsx(ToolbarSelect, { icon: IconTypography, label: strings.toolbar.fontFamily, width: 150, value: fontOptions.some((f) => f.family === shownFontFamily) ? shownFontFamily : null, placeholder: strings.toolbar.fontFamilyPlaceholder, data: fontData, searchable: true, noMatchMessage: strings.toolbar.noMatch, renderOption: ({ option }) => _jsx("span", { style: { fontFamily: option.value }, children: option.label }), onChange: withRefocus((v) => applyFont('font-family', v)) })), config.font.size && (_jsx(ToolbarSelect, { icon: IconTextSize, label: strings.toolbar.fontSize, width: 84, value: FONT_SIZES_PX.some((px) => `${px}px` === shownFontSize) ? shownFontSize : null, placeholder: strings.toolbar.fontSizePlaceholder, data: FONT_SIZES_PX.map((px) => ({ value: `${px}px`, label: String(px) })), onChange: withRefocus((v) => applyFont('font-size', v)) }))] }, "font")),
-        showAlignGroup && (_jsx("div", { className: "likhari-toolbar-group", children: _jsx(ToolbarSelect, { icon: AlignIcon, label: strings.toolbar.alignment, width: 138, value: state.elementFormat || 'start', data: alignOptions, renderOption: iconOptionRenderer(ALIGN_ICONS, IconAlignLeft), onChange: withRefocus((v) => formatElement(v)) }) }, "align")),
-        config.links && (_jsx("div", { className: "likhari-toolbar-group", children: state.isLink ? (
-            // Caret is in a link: the button opens a menu to see, edit or remove it.
-            _jsxs(Menu, { position: "bottom-start", withinPortal: true, portalProps: { target: portalTarget }, shadow: "sm", width: 240, onOpen: snapshotSelection, children: [_jsx(Menu.Target, { children: _jsx("button", { type: "button", className: "likhari-toolbar-button", "data-active": "true", "aria-pressed": "true", "aria-haspopup": "menu", "aria-label": strings.toolbar.linkOptions, title: strings.toolbar.linkOptions, onMouseDown: (e) => e.preventDefault(), children: _jsx(IconLink, { size: ICON_SIZE, stroke: ICON_STROKE }) }) }), _jsx(Menu.Dropdown, { children: _jsx(LinkMenuItems, { url: state.linkUrl, onEdit: () => {
-                                restoreSelection();
-                                openLinkDialog();
-                            }, onRemove: removeLink, strings: strings }) })] })) : (_jsx(ToolbarButton, { icon: IconLink, title: strings.toolbar.insertLink, onClick: openLinkDialog })) }, "link")),
-        showStubInsertGroup && (_jsxs("div", { className: "likhari-toolbar-group likhari-toolbar-group--collapse-tablet", children: [(config.images.linked || config.images.embedded) && (_jsx(ToolbarButton, { icon: IconPhoto, title: strings.toolbar.insertImage, onClick: openImageDialog })), config.blocks.pageBreak && (_jsx(ToolbarButton, { icon: IconPageBreak, title: strings.toolbar.insertPageBreak, onClick: () => editor.dispatchCommand(INSERT_PAGE_BREAK_COMMAND, undefined) })), config.tables && _jsx(ToolbarButton, { icon: IconTable, title: strings.toolbar.insertTable, onClick: openTableDialog }), config.columns && _jsx(ToolbarButton, { icon: IconColumns, title: strings.toolbar.insertColumns, onClick: openLayoutDialog }), config.footnotes && (_jsx(ToolbarButton, { icon: IconNumber1Small, title: strings.toolbar.insertFootnote, onClick: () => editor.dispatchCommand(INSERT_FOOTNOTE_COMMAND, undefined) })), config.blocks.horizontalRule && (_jsx(ToolbarButton, { icon: IconSeparatorHorizontal, title: strings.toolbar.insertHorizontalRule, onClick: () => editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined) })), config.findReplace && (_jsx(ToolbarButton, { icon: IconSearch, title: strings.findReplace.toggle, active: findOpen, onClick: onToggleFind })), config.poetry.enabled && locale !== 'en' && (_jsx(ToolbarButton, { icon: IconFeather, title: strings.toolbar.insertPoetryCouplet, onClick: () => editor.dispatchCommand(INSERT_POETRY_COUPLET_COMMAND, { layout: config.poetry.defaultLayout }) }))] }, "stubInsert")),
-        config.tables && state.inTable && (_jsx("div", { className: "likhari-toolbar-group", children: _jsxs(Menu, { position: "bottom-start", withinPortal: true, portalProps: { target: portalTarget }, shadow: "sm", width: 240, onOpen: snapshotSelection, children: [_jsx(Menu.Target, { children: _jsx("button", { type: "button", className: "likhari-toolbar-button", "data-active": "true", "aria-pressed": "true", "aria-haspopup": "menu", "aria-label": strings.toolbar.tableOptions, title: strings.toolbar.tableOptions, onMouseDown: (e) => e.preventDefault(), children: _jsx(IconTableOptions, { size: ICON_SIZE, stroke: ICON_STROKE }) }) }), _jsx(Menu.Dropdown, { children: _jsx(TableMenuItems, { strings: strings, direction: direction, rows: state.tableRows, columns: state.tableColumns, canMergeCells: state.canMergeCells, canUnmergeCell: state.canUnmergeCell, onAction: runMenuAction }) })] }) }, "tableActions")),
-        config.poetry.enabled && state.inPoetry && (_jsx("div", { className: "likhari-toolbar-group", children: _jsxs(Menu, { position: "bottom-start", withinPortal: true, portalProps: { target: portalTarget }, shadow: "sm", width: 200, onOpen: snapshotSelection, children: [_jsx(Menu.Target, { children: _jsx("button", { type: "button", className: "likhari-toolbar-button", "data-active": "true", "aria-pressed": "true", "aria-haspopup": "menu", "aria-label": strings.toolbar.poetryOptions, title: strings.toolbar.poetryOptions, onMouseDown: (e) => e.preventDefault(), children: _jsx(IconFeather, { size: ICON_SIZE, stroke: ICON_STROKE }) }) }), _jsx(Menu.Dropdown, { children: _jsx(PoetryMenuItems, { strings: strings, layout: state.poetryLayout, scale: state.poetryScale, centered: state.poetryCentered, onAction: runMenuAction }) })] }) }, "poetryActions")),
-        showLanguageGroup && (_jsxs("div", { className: "likhari-toolbar-group likhari-toolbar-group--collapse-tablet", children: [config.language.autocorrect && (_jsx(ToolbarButton, { icon: IconWand, title: strings.toolbar.autocorrect, active: autoCorrectOpen, onClick: onToggleAutoCorrect })), config.language.textCleanup && (_jsx(ToolbarButton, { icon: IconSparkles, title: strings.autoCorrect.correctDocument, onClick: () => editor.dispatchCommand(CORRECT_DOCUMENT_COMMAND, undefined) })), config.language.spellCheck && (_jsx(ToolbarButton, { icon: IconAbc, title: strings.toolbar.spellChecker, active: spellOpen, onClick: onToggleSpell }))] }, "language")),
+    const formatSection = (showFormattingGroup || fmt.bold || fmt.italic || fmt.underline || fmt.strikethrough || moreItems.length > 0) && (_jsxs(Fragment, { children: [showFormattingGroup && (_jsx(MantineToolbar.Group, { children: _jsx(ToolbarSelect, { icon: IconPilcrow, label: strings.toolbar.formattingLabel, width: 148, value: formattingValue, data: formattingOptions, comingSoon: strings.toolbar.comingSoon, renderOption: iconOptionRenderer(FORMATTING_ICONS, IconPilcrow), onChange: withRefocus((v) => applyFormatting(v)) }) })), (fmt.bold || fmt.italic || fmt.underline || fmt.strikethrough || moreItems.length > 0) && (_jsxs(MantineToolbar.Group, { className: "likhari-toolbar-cluster", children: [fmt.bold && _jsx(ToolbarButton, { icon: IconBold, title: strings.toolbar.bold, active: state.activeFormats.has('bold'), onClick: () => formatText('bold') }), fmt.italic && (_jsx(ToolbarButton, { icon: IconItalic, title: strings.toolbar.italic, active: state.activeFormats.has('italic'), onClick: () => formatText('italic') })), fmt.underline && (_jsx(ToolbarButton, { icon: IconUnderline, title: strings.toolbar.underline, active: state.activeFormats.has('underline'), onClick: () => formatText('underline') })), fmt.strikethrough && (_jsx(ToolbarButton, { icon: IconStrikethrough, title: strings.toolbar.strikethrough, active: state.activeFormats.has('strikethrough'), onClick: () => formatText('strikethrough') })), moreItems.length > 0 && (_jsxs(Menu, { position: "bottom-start", withinPortal: true, portalProps: { target: portalTarget }, shadow: "sm", width: 210, closeOnItemClick: true, onOpen: snapshotSelection, children: [_jsx(Menu.Target, { children: _jsx(ToolbarButton, { icon: IconDots, title: strings.toolbar.moreFormatting }) }), _jsx(Menu.Dropdown, { children: moreItems.map((item) => (_jsx(MoreMenuItem, { icon: item.icon, label: item.label, active: item.active, onClick: runMenuItem(item.onClick) }, item.key))) })] }))] }))] }, "format"));
+    const alignSection = (showAlignGroup || indentItems.length > 0) && (_jsxs(Fragment, { children: [showAlignGroup && (_jsx(MantineToolbar.Group, { children: _jsx(ToolbarSelect, { icon: AlignIcon, label: strings.toolbar.alignment, width: 138, value: state.elementFormat || 'start', data: alignOptions, renderOption: iconOptionRenderer(ALIGN_ICONS, IconAlignLeft), onChange: withRefocus((v) => formatElement(v)) }) })), indentItems.length > 0 && (_jsx(MantineToolbar.Group, { className: "likhari-toolbar-cluster", children: indentItems.map((item) => (_jsx(ToolbarButton, { icon: item.icon, title: item.label, onClick: item.onClick }, item.key))) }))] }, "align"));
+    const fontSection = (config.font.family || config.font.size) && (_jsxs(MantineToolbar.Group, { children: [config.font.family && (_jsx(ToolbarSelect, { icon: IconTypography, label: strings.toolbar.fontFamily, width: 150, value: fontOptions.some((f) => f.family === shownFontFamily) ? shownFontFamily : null, placeholder: strings.toolbar.fontFamilyPlaceholder, data: fontData, searchable: true, noMatchMessage: strings.toolbar.noMatch, renderOption: ({ option }) => _jsx("span", { style: { fontFamily: option.value }, children: option.label }), onChange: withRefocus((v) => applyFont('font-family', v)) })), config.font.size && (_jsx(ToolbarSelect, { icon: IconTextSize, label: strings.toolbar.fontSize, width: 84, value: FONT_SIZES_PX.some((px) => `${px}px` === shownFontSize) ? shownFontSize : null, placeholder: strings.toolbar.fontSizePlaceholder, data: FONT_SIZES_PX.map((px) => ({ value: `${px}px`, label: String(px) })), onChange: withRefocus((v) => applyFont('font-size', v)) }))] }, "font"));
+    const insertSection = showInsertGroup && (_jsxs(MantineToolbar.Group, { className: "likhari-toolbar-cluster", children: [config.links &&
+                (state.isLink ? (_jsxs(Menu, { position: "bottom-start", withinPortal: true, portalProps: { target: portalTarget }, shadow: "sm", width: 240, onOpen: snapshotSelection, children: [_jsx(Menu.Target, { children: _jsx(ToolbarButton, { icon: IconLink, title: strings.toolbar.linkOptions, active: true, "aria-haspopup": "menu" }) }), _jsx(Menu.Dropdown, { children: _jsx(LinkMenuItems, { url: state.linkUrl, onEdit: () => {
+                                    restoreSelection();
+                                    openLinkDialog();
+                                }, onRemove: removeLink, strings: strings }) })] })) : (_jsx(ToolbarButton, { icon: IconLink, title: strings.toolbar.insertLink, onClick: openLinkDialog }))), (config.images.linked || config.images.embedded) && (_jsx(ToolbarButton, { icon: IconPhoto, title: strings.toolbar.insertImage, onClick: openImageDialog })), config.blocks.horizontalRule && (_jsx(ToolbarButton, { icon: IconSeparatorHorizontal, title: strings.toolbar.insertHorizontalRule, onClick: () => editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined) })), config.tables && _jsx(ToolbarButton, { icon: IconTable, title: strings.toolbar.insertTable, onClick: openTableDialog }), config.tables && state.inTable && (_jsxs(Menu, { position: "bottom-start", withinPortal: true, portalProps: { target: portalTarget }, shadow: "sm", width: 240, onOpen: snapshotSelection, children: [_jsx(Menu.Target, { children: _jsx(ToolbarButton, { icon: IconTableOptions, title: strings.toolbar.tableOptions, active: true, "aria-haspopup": "menu" }) }), _jsx(Menu.Dropdown, { children: _jsx(TableMenuItems, { strings: strings, direction: direction, rows: state.tableRows, columns: state.tableColumns, canMergeCells: state.canMergeCells, canUnmergeCell: state.canUnmergeCell, onAction: runMenuAction }) })] })), config.columns && _jsx(ToolbarButton, { icon: IconColumns, title: strings.toolbar.insertColumns, onClick: openLayoutDialog }), config.footnotes && (_jsx(ToolbarButton, { icon: IconNumber1Small, title: strings.toolbar.insertFootnote, onClick: () => editor.dispatchCommand(INSERT_FOOTNOTE_COMMAND, undefined) })), config.blocks.pageBreak && (_jsx(ToolbarButton, { icon: IconPageBreak, title: strings.toolbar.insertPageBreak, onClick: () => editor.dispatchCommand(INSERT_PAGE_BREAK_COMMAND, undefined) })), config.poetry.enabled && locale !== 'en' && (_jsx(ToolbarButton, { icon: IconFeather, title: strings.toolbar.insertPoetryCouplet, onClick: () => editor.dispatchCommand(INSERT_POETRY_COUPLET_COMMAND, { layout: config.poetry.defaultLayout }) })), config.poetry.enabled && state.inPoetry && (_jsxs(Menu, { position: "bottom-start", withinPortal: true, portalProps: { target: portalTarget }, shadow: "sm", width: 200, onOpen: snapshotSelection, children: [_jsx(Menu.Target, { children: _jsx(ToolbarButton, { icon: IconFeather, title: strings.toolbar.poetryOptions, active: true, "aria-haspopup": "menu" }) }), _jsx(Menu.Dropdown, { children: _jsx(PoetryMenuItems, { strings: strings, layout: state.poetryLayout, scale: state.poetryScale, centered: state.poetryCentered, onAction: runMenuAction }) })] }))] }, "insert"));
+    const toolsSection = showLanguageGroup && (_jsxs(MantineToolbar.Group, { className: "likhari-toolbar-cluster", children: [config.language.autocorrect && (_jsx(ToolbarButton, { icon: IconWand, title: strings.toolbar.autocorrect, active: autoCorrectOpen, onClick: onToggleAutoCorrect })), config.language.textCleanup && (_jsx(ToolbarButton, { icon: IconSparkles, title: strings.autoCorrect.correctDocument, onClick: () => editor.dispatchCommand(CORRECT_DOCUMENT_COMMAND, undefined) })), config.language.spellCheck && (_jsx(ToolbarButton, { icon: IconAbc, title: strings.toolbar.spellChecker, active: spellOpen, onClick: onToggleSpell }))] }, "tools"));
+    const endSection = (drafts || config.findReplace) && (_jsxs(MantineToolbar.Group, { className: "likhari-toolbar-cluster", style: { marginInlineStart: 'auto' }, children: [drafts && _jsx(ToolbarButton, { icon: IconHistory, title: strings.toolbar.drafts, onClick: () => setDraftsOpen(true) }), config.findReplace && (_jsx(ToolbarButton, { icon: IconSearch, title: strings.findReplace.toggle, active: findOpen, onClick: onToggleFind }))] }, "end"));
+    const startSections = [
+        showSave && (_jsx(MantineToolbar.Group, { className: "likhari-toolbar-cluster", children: _jsx(ToolbarButton, { icon: IconDeviceFloppy, title: strings.toolbar.save, dirty: Boolean(isDirty), onClick: onSave }) }, "save")),
+        config.history && (_jsxs(MantineToolbar.Group, { className: "likhari-toolbar-cluster", children: [_jsx(ToolbarButton, { icon: IconArrowBackUp, title: strings.toolbar.undo, disabled: !state.canUndo, onClick: () => editor.dispatchCommand(UNDO_COMMAND, undefined) }), _jsx(ToolbarButton, { icon: IconArrowForwardUp, title: strings.toolbar.redo, disabled: !state.canRedo, onClick: () => editor.dispatchCommand(REDO_COMMAND, undefined) })] }, "history")),
+        formatSection,
+        alignSection,
+        fontSection,
+        insertSection,
+        toolsSection,
     ];
-    return (_jsxs("div", { className: "likhari-toolbar", role: "toolbar", "aria-label": strings.toolbar.ariaLabel, ref: toolbarContainerRef, children: [fixedGroups, movableGroups
-                .filter((group) => !overflowGroupKeys.has(group.key))
-                .map((group) => (_jsx(MovableGroupButtons, { group: group }, group.key))), overflowGroupKeys.size > 0 && (_jsxs(Menu, { position: "bottom-end", withinPortal: true, portalProps: { target: portalTarget }, shadow: "sm", width: 210, closeOnItemClick: true, onOpen: snapshotSelection, children: [_jsx(Menu.Target, { children: _jsx("button", { type: "button", className: "likhari-toolbar-button", "aria-label": strings.toolbar.moreFormatting, title: strings.toolbar.moreFormatting, onMouseDown: (e) => e.preventDefault(), children: _jsx(IconDots, { size: ICON_SIZE, stroke: ICON_STROKE }) }) }), _jsx(Menu.Dropdown, { children: movableGroups
-                            .filter((group) => overflowGroupKeys.has(group.key))
-                            .flatMap((group) => group.items.map((item) => (_jsx(OverflowItem, { icon: item.icon, label: item.label, active: item.active, onClick: runOverflowAction(item.onClick) }, item.key)))) })] })), _jsxs(Menu, { opened: contextMenu !== null, onChange: (opened) => {
+    return (_jsxs(MantineToolbar, { "aria-label": strings.toolbar.ariaLabel, className: "likhari-toolbar", children: [withDividers(startSections), endSection, _jsxs(Menu, { opened: contextMenu !== null, onChange: (opened) => {
                     if (!opened)
                         setContextMenu(null);
                 }, position: "bottom-start", withinPortal: true, portalProps: { target: portalTarget }, shadow: "sm", width: 260, children: [_jsx(Menu.Target, { children: _jsx("span", { "aria-hidden": "true", style: { position: 'fixed', left: contextMenu?.x ?? -9999, top: contextMenu?.y ?? -9999, width: 1, height: 1, pointerEvents: 'none' } }) }), _jsxs(Menu.Dropdown, { children: [contextMenu?.spelling && (_jsxs(_Fragment, { children: [_jsx(Menu.Label, { children: strings.contextMenu.spelling }), contextMenu.spelling.suggestions.length === 0 && _jsx(Menu.Item, { disabled: true, children: strings.contextMenu.noSuggestions }), contextMenu.spelling.suggestions.map((suggestion) => (_jsx(Menu.Item, { onClick: () => {
@@ -864,14 +770,5 @@ export function Toolbar({ config, dictionaryStores = [], thesaurusStores = [], o
                                         }, children: synonym }, synonym))), _jsx(Menu.Divider, {})] })), contextMenu?.link !== undefined && (_jsxs(_Fragment, { children: [_jsx(LinkMenuItems, { url: contextMenu.link, onEdit: () => {
                                             restoreSelection();
                                             openLinkDialog();
-                                        }, onRemove: removeLink, strings: strings }), _jsx(Menu.Divider, {})] })), contextMenu?.table && (_jsxs(_Fragment, { children: [_jsx(TableMenuItems, { strings: strings, direction: direction, rows: contextMenu.table.rows, columns: contextMenu.table.columns, canMergeCells: state.canMergeCells, canUnmergeCell: state.canUnmergeCell, onAction: runMenuAction }), _jsx(Menu.Divider, {})] })), contextMenu?.poetry && (_jsxs(_Fragment, { children: [_jsx(PoetryMenuItems, { strings: strings, layout: state.poetryLayout, scale: state.poetryScale, centered: state.poetryCentered, onAction: runMenuAction }), _jsx(Menu.Divider, {})] })), _jsx(Menu.Item, { leftSection: _jsx(IconCut, { size: ICON_SIZE, stroke: ICON_STROKE }), onClick: () => void copyOrCut(true)(), children: strings.contextMenu.cut }), _jsx(Menu.Item, { leftSection: _jsx(IconCopy, { size: ICON_SIZE, stroke: ICON_STROKE }), onClick: () => void copyOrCut(false)(), children: strings.contextMenu.copy }), _jsx(Menu.Item, { leftSection: _jsx(IconClipboard, { size: ICON_SIZE, stroke: ICON_STROKE }), onClick: () => void paste(), children: strings.contextMenu.paste }), _jsx(Menu.Item, { leftSection: _jsx(IconSelectAll, { size: ICON_SIZE, stroke: ICON_STROKE }), onClick: runMenuAction(() => $selectAll()), children: strings.contextMenu.selectAll })] })] }), _jsxs("div", { "aria-hidden": "true", ref: toolbarMeasureRef, style: {
-                    position: 'absolute',
-                    visibility: 'hidden',
-                    pointerEvents: 'none',
-                    top: 0,
-                    left: 0,
-                    display: 'flex',
-                    flexWrap: 'nowrap',
-                    gap: 8,
-                }, children: [fixedGroups, movableGroups.map((group) => (_jsx(MovableGroupButtons, { group: group }, group.key)))] }), (config.images.linked || config.images.embedded) && (_jsx(ImageDialog, { mode: "insert", opened: imageDialogOpen, onSubmit: insertImage, onClose: closeImageDialog })), config.tables && _jsx(TableDialog, { opened: tableDialogOpen, onSubmit: insertTable, onClose: closeTableDialog }), config.columns && _jsx(LayoutDialog, { opened: layoutDialogOpen, onSubmit: insertLayout, onClose: closeLayoutDialog }), config.links && (_jsx(LinkDialog, { opened: linkDialogOpen, initialUrl: state.linkUrl, showTextField: linkNeedsText, onSubmit: applyLink, onRemove: state.isLink ? removeLink : undefined, onClose: closeLinkDialog })), drafts && _jsx(DraftsDialog, { opened: draftsOpen, locale: locale, onClose: () => setDraftsOpen(false), ...drafts })] }));
+                                        }, onRemove: removeLink, strings: strings }), _jsx(Menu.Divider, {})] })), contextMenu?.table && (_jsxs(_Fragment, { children: [_jsx(TableMenuItems, { strings: strings, direction: direction, rows: contextMenu.table.rows, columns: contextMenu.table.columns, canMergeCells: state.canMergeCells, canUnmergeCell: state.canUnmergeCell, onAction: runMenuAction }), _jsx(Menu.Divider, {})] })), contextMenu?.poetry && (_jsxs(_Fragment, { children: [_jsx(PoetryMenuItems, { strings: strings, layout: state.poetryLayout, scale: state.poetryScale, centered: state.poetryCentered, onAction: runMenuAction }), _jsx(Menu.Divider, {})] })), _jsx(Menu.Item, { leftSection: _jsx(IconCut, { size: ICON_SIZE, stroke: ICON_STROKE }), onClick: () => void copyOrCut(true)(), children: strings.contextMenu.cut }), _jsx(Menu.Item, { leftSection: _jsx(IconCopy, { size: ICON_SIZE, stroke: ICON_STROKE }), onClick: () => void copyOrCut(false)(), children: strings.contextMenu.copy }), _jsx(Menu.Item, { leftSection: _jsx(IconClipboard, { size: ICON_SIZE, stroke: ICON_STROKE }), onClick: () => void paste(), children: strings.contextMenu.paste }), _jsx(Menu.Item, { leftSection: _jsx(IconSelectAll, { size: ICON_SIZE, stroke: ICON_STROKE }), onClick: runMenuAction(() => $selectAll()), children: strings.contextMenu.selectAll })] })] }), (config.images.linked || config.images.embedded) && (_jsx(ImageDialog, { mode: "insert", opened: imageDialogOpen, onSubmit: insertImage, onClose: closeImageDialog })), config.tables && _jsx(TableDialog, { opened: tableDialogOpen, onSubmit: insertTable, onClose: closeTableDialog }), config.columns && _jsx(LayoutDialog, { opened: layoutDialogOpen, onSubmit: insertLayout, onClose: closeLayoutDialog }), config.links && (_jsx(LinkDialog, { opened: linkDialogOpen, initialUrl: state.linkUrl, showTextField: linkNeedsText, onSubmit: applyLink, onRemove: state.isLink ? removeLink : undefined, onClose: closeLinkDialog })), drafts && _jsx(DraftsDialog, { opened: draftsOpen, locale: locale, onClose: () => setDraftsOpen(false), ...drafts })] }));
 }

package/dist/i18n/strings.js

@@ -52,7 +52,7 @@ const en = {
         subscript: 'Subscript',
         uppercase: 'UPPERCASE',
         lowercase: 'lowercase',
-        capitalize: 'Capitalize',
+        capitalize: 'InitCap',
         clearFormatting: 'Clear formatting',
         outdent: 'Outdent',
         indent: 'Indent',

package/dist/spellcheck/SpellHighlightPlugin.d.ts

@@ -1,8 +1,10 @@
 /**
  * Underlines misspelled words the way the browser does, without changing the
- * document: ranges are set on the rendered text through the CSS Custom
- * Highlight API. Checking is debounced so typing stays smooth. In browsers
- * without the API, nothing is underlined.
+ * document. Only blocks that are in view are checked, a block a few seconds after
+ * it scrolls into view, and an edit is rechecked after typing pauses. Results are
+ * kept per block, so a change re-checks only the block it is in. Underlines are
+ * ranges set through the CSS Custom Highlight API. In browsers without it, nothing
+ * is underlined.
  */
 export declare function SpellHighlightPlugin(): null;
 //# sourceMappingURL=SpellHighlightPlugin.d.ts.map

package/dist/spellcheck/SpellHighlightPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpellHighlightPlugin.d.ts","sourceRoot":"","sources":["../../src/spellcheck/SpellHighlightPlugin.tsx"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,wBAAgB,oBAAoB,SAkDnC"}
+{"version":3,"file":"SpellHighlightPlugin.d.ts","sourceRoot":"","sources":["../../src/spellcheck/SpellHighlightPlugin.tsx"],"names":[],"mappings":"AAsBA;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,SAoJnC"}

package/dist/spellcheck/SpellHighlightPlugin.js

@@ -1,60 +1,196 @@
 import { useEffect } from 'react';
 import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
-import { $collectMisspellings } from './spellcheckActions.js';
+import { $getNodeByKey, $getRoot, $isElementNode } from 'lexical';
+import { $misspellingsInBlock } from './spellcheckActions.js';
 import { getSpeller } from './spellDictionaries.js';
 import { onSpellWordsChange } from './userWords.js';
 /** The CSS Custom Highlight name; editor.css styles it as a red wavy underline. */
 const HIGHLIGHT = 'likhari-spelling';
-const DEBOUNCE_MS = 300;
+/** A block that has just come into view is checked after this long, so scrolling past it costs nothing. */
+const VIEW_DELAY_MS = 2000;
+/** An edit inside a visible block is checked after the typing pauses for this long. */
+const TYPING_DELAY_MS = 300;
+/** The top-level block (paragraph, table, list...) that holds a node, or null. */
+function $topLevelKey(node) {
+    const root = $getRoot();
+    let current = node;
+    while (current.getParent() && !current.getParent().is(root))
+        current = current.getParent();
+    return current.getParent() ? current.getKey() : null;
+}
 /**
  * Underlines misspelled words the way the browser does, without changing the
- * document: ranges are set on the rendered text through the CSS Custom
- * Highlight API. Checking is debounced so typing stays smooth. In browsers
- * without the API, nothing is underlined.
+ * document. Only blocks that are in view are checked, a block a few seconds after
+ * it scrolls into view, and an edit is rechecked after typing pauses. Results are
+ * kept per block, so a change re-checks only the block it is in. Underlines are
+ * ranges set through the CSS Custom Highlight API. In browsers without it, nothing
+ * is underlined.
  */
 export function SpellHighlightPlugin() {
     const [editor] = useLexicalComposerContext();
     useEffect(() => {
-        if (typeof CSS === 'undefined' || !('highlights' in CSS))
+        if (typeof CSS === 'undefined' || !('highlights' in CSS) || typeof IntersectionObserver === 'undefined')
             return;
         let checkers = null;
-        let timer;
         let active = true;
+        const cache = new Map();
+        const visible = new Set();
+        const elements = new Map();
+        const keyOf = new Map();
+        const timers = new Map();
         const paint = () => {
-            if (!active || !checkers)
-                return;
-            const found = editor.getEditorState().read(() => $collectMisspellings(checkers));
             const ranges = [];
-            for (const misspelling of found) {
-                for (const segment of misspelling.segments) {
-                    const text = editor.getElementByKey(segment.key)?.firstChild;
-                    if (!text || text.nodeType !== Node.TEXT_NODE)
-                        continue;
-                    const range = document.createRange();
-                    range.setStart(text, segment.start);
-                    range.setEnd(text, segment.end);
-                    ranges.push(range);
+            for (const [key, words] of cache) {
+                const block = editor.getElementByKey(key);
+                if (!block || words.length === 0)
+                    continue;
+                const pieces = textPieces(block);
+                for (const word of words) {
+                    for (const piece of pieces) {
+                        const start = Math.max(word.start, piece.start);
+                        const end = Math.min(word.end, piece.end);
+                        if (end <= start)
+                            continue;
+                        const range = document.createRange();
+                        range.setStart(piece.node, start - piece.start);
+                        range.setEnd(piece.node, end - piece.start);
+                        ranges.push(range);
+                    }
                 }
             }
             CSS.highlights.set(HIGHLIGHT, new Highlight(...ranges));
         };
-        const schedule = () => {
-            clearTimeout(timer);
-            timer = setTimeout(paint, DEBOUNCE_MS);
+        const checkBlock = (key) => {
+            if (!active || !checkers)
+                return;
+            const words = editor.getEditorState().read(() => {
+                const node = $getNodeByKey(key);
+                return $isElementNode(node) ? $misspellingsInBlock(node, checkers) : null;
+            });
+            if (words === null)
+                cache.delete(key);
+            else
+                cache.set(key, words);
+            paint();
+        };
+        const schedule = (key, delay) => {
+            clearTimeout(timers.get(key));
+            timers.set(key, setTimeout(() => {
+                timers.delete(key);
+                if (visible.has(key))
+                    checkBlock(key);
+            }, delay));
+        };
+        const observer = new IntersectionObserver((entries) => {
+            for (const entry of entries) {
+                const key = keyOf.get(entry.target);
+                if (key === undefined)
+                    continue;
+                if (entry.isIntersecting) {
+                    visible.add(key);
+                    if (!cache.has(key))
+                        schedule(key, VIEW_DELAY_MS);
+                }
+                else {
+                    visible.delete(key);
+                    clearTimeout(timers.get(key));
+                    timers.delete(key);
+                }
+            }
+        });
+        // Keeps the observer on exactly the current top-level blocks.
+        const syncBlocks = (editorState = editor.getEditorState()) => {
+            const current = new Map();
+            editorState.read(() => {
+                for (const block of $getRoot().getChildren()) {
+                    const element = editor.getElementByKey(block.getKey());
+                    if (element)
+                        current.set(block.getKey(), element);
+                }
+            });
+            for (const [key, element] of elements) {
+                if (current.get(key) !== element) {
+                    observer.unobserve(element);
+                    keyOf.delete(element);
+                    elements.delete(key);
+                    visible.delete(key);
+                    cache.delete(key);
+                    clearTimeout(timers.get(key));
+                    timers.delete(key);
+                }
+            }
+            for (const [key, element] of current) {
+                if (!elements.has(key)) {
+                    elements.set(key, element);
+                    keyOf.set(element, key);
+                    observer.observe(element);
+                }
+            }
         };
-        const unregister = editor.registerUpdateListener(schedule);
-        const unsubscribe = onSpellWordsChange(schedule);
+        const unregisterUpdate = editor.registerUpdateListener(({ editorState, dirtyElements, dirtyLeaves }) => {
+            if (!checkers)
+                return;
+            const dirty = new Set();
+            editorState.read(() => {
+                for (const key of dirtyLeaves) {
+                    const node = $getNodeByKey(key);
+                    const top = node ? $topLevelKey(node) : null;
+                    if (top)
+                        dirty.add(top);
+                }
+                for (const key of dirtyElements.keys()) {
+                    const node = $getNodeByKey(key);
+                    const top = node ? $topLevelKey(node) : null;
+                    if (top)
+                        dirty.add(top);
+                }
+            });
+            syncBlocks(editorState);
+            for (const key of dirty) {
+                if (visible.has(key))
+                    schedule(key, TYPING_DELAY_MS);
+                else
+                    cache.delete(key);
+            }
+            if (dirty.size > 0)
+                paint();
+        });
+        const unsubscribeWords = onSpellWordsChange(() => {
+            cache.clear();
+            for (const key of visible)
+                schedule(key, 0);
+            paint();
+        });
         Promise.all([getSpeller('en'), getSpeller('ur')]).then(async ([en, ur]) => {
+            if (!active)
+                return;
             checkers = { ltr: en ? await en : undefined, rtl: ur ? await ur : undefined };
-            schedule();
+            syncBlocks();
+            for (const key of visible)
+                if (!cache.has(key))
+                    schedule(key, 0);
         });
         return () => {
             active = false;
-            clearTimeout(timer);
-            unregister();
-            unsubscribe();
+            observer.disconnect();
+            unregisterUpdate();
+            unsubscribeWords();
+            for (const timer of timers.values())
+                clearTimeout(timer);
             CSS.highlights.delete(HIGHLIGHT);
         };
     }, [editor]);
     return null;
 }
+/** The text nodes of a rendered block, with where each one starts in the block's text. */
+function textPieces(block) {
+    const pieces = [];
+    const walker = document.createTreeWalker(block, NodeFilter.SHOW_TEXT);
+    let offset = 0;
+    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+        const text = node;
+        pieces.push({ node: text, start: offset, end: offset + text.length });
+        offset += text.length;
+    }
+    return pieces;
+}

package/dist/spellcheck/spellcheckActions.d.ts

@@ -1,3 +1,4 @@
+import type { ElementNode } from 'lexical';
 import { type FindMatch } from '../find/findReplaceActions.js';
 import { type Speller } from './spellDictionaries.js';
 /** The checker for each text direction: English for LTR blocks, Urdu for RTL. */
@@ -18,4 +19,16 @@ export interface Misspelling {
 }
 /** Every word in the document its block's checker does not recognise. */
 export declare function $collectMisspellings(checkers: Checkers): Misspelling[];
+/** A misspelled word inside a block, as offsets into the block's text. */
+export interface BlockMisspelling {
+    start: number;
+    end: number;
+    word: string;
+}
+/**
+ * The misspelled words inside one top-level block (a paragraph, a table, a list...),
+ * as offsets into the block's text. Words are found per parent (paragraph or cell),
+ * so text in different cells never forms one word. Must run inside an editor read.
+ */
+export declare function $misspellingsInBlock(block: ElementNode, checkers: Checkers): BlockMisspelling[];
 //# sourceMappingURL=spellcheckActions.d.ts.map

package/dist/spellcheck/spellcheckActions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spellcheckActions.d.ts","sourceRoot":"","sources":["../../src/spellcheck/spellcheckActions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAClF,OAAO,EAAW,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE5D,iFAAiF;AACjF,MAAM,WAAW,QAAQ;IACvB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,qEAAqE;AACrE,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAED,yEAAyE;AACzE,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,EAAE,CAmBtE"}
+{"version":3,"file":"spellcheckActions.d.ts","sourceRoot":"","sources":["../../src/spellcheck/spellcheckActions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAwB,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAClF,OAAO,EAAW,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE5D,iFAAiF;AACjF,MAAM,WAAW,QAAQ;IACvB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,qEAAqE;AACrE,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAED,yEAAyE;AACzE,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,EAAE,CAmBtE;AAeD,0EAA0E;AAC1E,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,GAAG,gBAAgB,EAAE,CA8B/F"}

package/dist/spellcheck/spellcheckActions.js

@@ -36,3 +36,38 @@ function segmentsOf(group, start, end) {
     }
     return segments;
 }
+/**
+ * The misspelled words inside one top-level block (a paragraph, a table, a list...),
+ * as offsets into the block's text. Words are found per parent (paragraph or cell),
+ * so text in different cells never forms one word. Must run inside an editor read.
+ */
+export function $misspellingsInBlock(block, checkers) {
+    const nodes = block.getAllTextNodes();
+    const starts = [];
+    let offset = 0;
+    for (const node of nodes) {
+        starts.push(offset);
+        offset += node.getTextContent().length;
+    }
+    const found = [];
+    let i = 0;
+    while (i < nodes.length) {
+        const parent = nodes[i].getParentOrThrow();
+        let j = i;
+        let text = '';
+        while (j < nodes.length && nodes[j].getParentOrThrow().getKey() === parent.getKey()) {
+            text += nodes[j].getTextContent();
+            j += 1;
+        }
+        const speller = parent.getDirection() === 'rtl' ? checkers.rtl : checkers.ltr;
+        if (speller) {
+            for (const span of wordsIn(text)) {
+                if (!speller.correct(span.word)) {
+                    found.push({ start: starts[i] + span.start, end: starts[i] + span.end, word: span.word });
+                }
+            }
+        }
+        i = j;
+    }
+    return found;
+}

package/dist/theme/editor.css

@@ -19,12 +19,6 @@
    its own height so only the canvas below scrolls. */
 .likhari-toolbar {
   display: flex;
-  /* Containing block for the hidden width-measuring clone (Toolbar.tsx):
-     without this, its position: absolute would resolve against the
-     viewport instead, and its intentionally-unwrapped (possibly very wide)
-     content could inflate the host page's scroll area instead of being
-     clipped by .likhari-root's overflow: hidden. */
-  position: relative;
   flex-shrink: 0;
   align-items: center;
   gap: 8px;
@@ -57,55 +51,6 @@
   pointer-events: auto;
 }
 
-.likhari-toolbar-group {
-  display: flex;
-  align-items: center;
-  gap: 2px;
-  padding: 0 6px;
-  border-inline-end: 0.5px solid var(--editor-line);
-}
-
-.likhari-toolbar-group:last-child {
-  border-inline-end: none;
-}
-
-.likhari-toolbar-button {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  min-width: 30px;
-  height: 30px;
-  padding: 0 6px;
-  border-radius: 6px;
-  border: none;
-  background: transparent;
-  color: var(--editor-ink);
-  cursor: pointer;
-}
-
-.likhari-toolbar-button svg {
-  display: block;
-}
-
-.likhari-toolbar-button:hover {
-  background: var(--editor-line);
-}
-
-.likhari-toolbar-button[data-active='true'] {
-  background: var(--editor-accent-soft);
-  color: var(--editor-accent);
-}
-
-.likhari-toolbar-button:focus-visible {
-  outline: 2px solid var(--editor-accent);
-  outline-offset: 1px;
-}
-
-.likhari-toolbar-button:disabled {
-  opacity: 0.4;
-  cursor: not-allowed;
-}
-
 /* Mantine Select inside the toolbar — sized to the 30px control height and
    themed from the --editor-* tokens (the closed input only; the dropdown is
    portaled to <body>, outside the token scope, so it uses Mantine's own
@@ -125,35 +70,35 @@
   cursor: not-allowed;
 }
 
-.likhari-overflow-item[data-active='true'] {
-  background: var(--mantine-primary-color-light);
-  color: var(--mantine-primary-color-filled);
+/* A cluster of related buttons (undo/redo, bold/italic/underline/strikethrough, ...) reads as one control. */
+.likhari-toolbar-cluster {
+  border: 1px solid var(--editor-line-strong);
+  border-radius: 6px;
+  background: var(--editor-paper);
+  overflow: hidden;
 }
 
-/* Responsive collapse — editor-ui-design-spec.md §3.3. These groups hold
-   only not-yet-implemented placeholders, so hiding them below the tablet
-   breakpoint costs nothing functional while keeping the primary row usable
-   on small screens; the toolbar wraps onto a second row if the
-   still-visible controls alone overflow a narrow viewport. */
-@media (max-width: 900px) {
-  .likhari-toolbar-group--collapse-tablet {
-    display: none;
-  }
+.likhari-toolbar-cluster [data-toolbar-toggle] {
+  border: none;
+  border-radius: 0;
+}
+
+.likhari-toolbar-cluster [data-toolbar-toggle] + [data-toolbar-toggle] {
+  border-inline-start: 1px solid var(--editor-line);
 }
 
-/* Save (icon-only ToolbarButton): filled accent while there are unsaved
-   changes, back to the plain outline once saved — editor-ui-design-spec.md §7. */
-.likhari-toolbar-button[data-dirty='true'] {
+/* Save: filled accent while there are unsaved changes, back to the plain outline once saved. */
+.likhari-toolbar [data-dirty='true'] {
   background: var(--editor-accent);
   color: var(--editor-paper);
 }
 
-.likhari-toolbar-button[data-dirty='true']:hover {
+.likhari-toolbar [data-dirty='true']:hover {
   background: var(--editor-accent);
   filter: brightness(1.1);
 }
 
-.likhari-toolbar-button[data-dirty='false'] {
+.likhari-toolbar [data-dirty='false'] {
   color: var(--editor-accent);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inshapardaz/likhari-react",
-  "version": "0.1.28-dev.245",
+  "version": "0.1.28-dev.257",
   "description": "React implementation of the Likhari editor, built on @lexical/react.",
   "license": "MIT",
   "repository": {
@@ -47,14 +47,14 @@
     "nspell": "^2.1.5"
   },
   "peerDependencies": {
-    "@mantine/core": "^9.6.3",
-    "@mantine/hooks": "^9.6.3",
+    "@mantine/core": "^9.7.0",
+    "@mantine/hooks": "^9.7.0",
     "react": "^19.2.0",
     "react-dom": "^19.2.0"
   },
   "devDependencies": {
-    "@mantine/core": "^9.6.3",
-    "@mantine/hooks": "^9.6.3",
+    "@mantine/core": "^9.7.0",
+    "@mantine/hooks": "^9.7.0",
     "@types/nspell": "^2.1.6"
   }
 }