@inshapardaz/likhari-react 0.1.18-dev.158 → 0.1.18-dev.165

package/dist/blocks/poetryActions.js

@@ -1,7 +1,7 @@
 import { $findMatchingParent } from '@lexical/utils';
-import { $createParagraphNode, $getSelection, $isElementNode, $isParagraphNode, $isRangeSelection } from 'lexical';
+import { $createParagraphNode, $getSelection, $isElementNode, $isParagraphNode, $isRangeSelection, } from 'lexical';
 import { $createLayoutContainerNode, $createLayoutItemNode, $isLayoutContainerNode, $isLayoutItemNode } from './LayoutNode.js';
-import { $createPoetryBlockNode, $isPoetryBlockNode, POETRY_SPACINGS, } from './PoetryNode.js';
+import { $createPoetryBlockNode, $isPoetryBlockNode, POETRY_GUTTERS, POETRY_SPACINGS, POETRY_STAGGERS, } from './PoetryNode.js';
 /**
  * A poetry block is a *section* of one or more couplets sharing one layout
  * (single-column stacks each couplet's two misras directly as paragraph
@@ -11,7 +11,7 @@ import { $createPoetryBlockNode, $isPoetryBlockNode, POETRY_SPACINGS, } from './
  * read either shape, so nothing else needs to.
  */
 export function $getCouplets(node) {
-    if (node.getLayout() === 'single') {
+    if (node.getLayout() !== 'two-column') {
         const paragraphs = node.getChildren().filter($isParagraphNode);
         const couplets = [];
         for (let i = 0; i + 1 < paragraphs.length; i += 2)
@@ -22,6 +22,12 @@ export function $getCouplets(node) {
     const couplets = [];
     for (const container of containers) {
         const items = container.getChildren().filter($isLayoutItemNode);
+        if (items.length === 1) {
+            const [a, b] = items[0].getChildren();
+            if ($isParagraphNode(a) && $isParagraphNode(b))
+                couplets.push([a, b]);
+            continue;
+        }
         const a = items[0]?.getFirstChild();
         const b = items[1]?.getFirstChild();
         if ($isParagraphNode(a) && $isParagraphNode(b))
@@ -58,7 +64,7 @@ function $findCoupletPosition(couplets, target) {
 function $appendCoupletTo(node) {
     const misraA = $createParagraphNode();
     const misraB = $createParagraphNode();
-    if (node.getLayout() === 'single') {
+    if (node.getLayout() !== 'two-column') {
         node.append(misraA, misraB);
     }
     else {
@@ -80,7 +86,7 @@ function $appendCoupletTo(node) {
 function $insertCoupletRelativeTo(existingFirstMisra, layout, position) {
     const misraA = $createParagraphNode();
     const misraB = $createParagraphNode();
-    if (layout === 'single') {
+    if (layout !== 'two-column') {
         if (position === 'before') {
             existingFirstMisra.insertBefore(misraA);
             misraA.insertAfter(misraB);
@@ -143,7 +149,7 @@ export function $setPoetryLayout(node, layout) {
     }
     for (const leftover of node.getChildren())
         leftover.remove();
-    if (layout === 'single') {
+    if (layout !== 'two-column') {
         for (const [a, b] of couplets)
             node.append(a, b);
     }
@@ -174,10 +180,10 @@ export function $ensureTrailingParagraph(node) {
  * semantics, in its existing layout: "one poetry block can contain one or
  * more couplets, in one or two column layout", so a block's layout is
  * fixed once it has couplets, not chosen per couplet) and focuses its first
- * misra. Otherwise creates a new block (in `layout`/`align`) with one
+ * misra. Otherwise creates a new block (in `layout`) with one
  * couplet, after the selection's top-level element.
  */
-export function $insertPoetryCouplet(layout, align) {
+export function $insertPoetryCouplet(layout) {
     const selection = $getSelection();
     if (!$isRangeSelection(selection))
         return false;
@@ -186,7 +192,7 @@ export function $insertPoetryCouplet(layout, align) {
         return $insertCoupletRelativeToSelection('after');
     }
     const anchorTopLevel = selection.anchor.getNode().getTopLevelElementOrThrow();
-    const node = $createPoetryBlockNode(layout, align);
+    const node = $createPoetryBlockNode(layout);
     const [misraA] = $appendCoupletTo(node);
     anchorTopLevel.insertAfter(node);
     $ensureTrailingParagraph(node);
@@ -223,16 +229,23 @@ export function $deletePoetryCouplet() {
     }
     return true;
 }
+/** Whether a point sits at the very start (or, with `atEnd`, very end) of a paragraph. */
+function $isPointAt(paragraph, point, atEnd) {
+    if (point.key === paragraph.getKey())
+        return point.offset === (atEnd ? paragraph.getChildrenSize() : 0);
+    const edge = atEnd ? paragraph.getLastDescendant() : paragraph.getFirstDescendant();
+    if (point.getNode() !== edge)
+        return false;
+    return point.offset === (atEnd ? point.getNode().getTextContent().length : 0);
+}
 /**
- * Backspace at the very start of an empty couplet removes just that
- * couplet — merging back into the previous one's end, or (if it's the
- * block's only couplet) removing the whole block, since an empty poetry
- * section serves no purpose. Otherwise there was no way to get rid of an
- * empty couplet created by mistake (its misra paragraphs each have their
- * own default canBeEmpty, so Lexical's usual "delete the empty block"
- * handling never reaches the couplet itself). Returns false for every
- * other caret position, including a non-empty couplet, so normal Backspace
- * handling (e.g. deleting within text) proceeds.
+ * Backspace at the start of a misra never merges it into its neighbour: the
+ * block's lines are paired into couplets, so merging one line away would
+ * shift every couplet after it (and take the previous couplet's last line
+ * with it). Instead, Backspace at the start of an empty couplet removes that
+ * couplet, and at the start of any other line it moves the caret to the end
+ * of the previous line. Other caret positions (deleting within text) fall
+ * through to normal handling.
  */
 export function $deletePoetryOnBackspace() {
     const selection = $getSelection();
@@ -242,35 +255,60 @@ export function $deletePoetryOnBackspace() {
     if (!block)
         return false;
     const couplets = $getCouplets(block);
-    const anchorNode = selection.anchor.getNode();
-    const position = $findCoupletPosition(couplets, anchorNode);
-    if (!position || position.misraIndex !== 0)
-        return false;
-    const [firstMisra] = couplets[position.coupletIndex];
-    const anchor = selection.anchor;
-    const isAtStart = anchor.key === firstMisra.getKey() && anchor.offset === 0;
-    if (!isAtStart)
+    const position = $findCoupletPosition(couplets, selection.anchor.getNode());
+    if (!position)
         return false;
-    const [a, b] = couplets[position.coupletIndex];
-    if (!a.isEmpty() || !b.isEmpty())
+    const { coupletIndex, misraIndex } = position;
+    const [a, b] = couplets[coupletIndex];
+    const misra = couplets[coupletIndex][misraIndex];
+    if (!$isPointAt(misra, selection.anchor, false))
         return false;
-    if (couplets.length <= 1) {
-        const previous = block.getPreviousSibling();
-        block.remove();
-        if ($isElementNode(previous))
-            previous.selectEnd();
+    if (a.isEmpty() && b.isEmpty()) {
+        if (couplets.length <= 1) {
+            const previous = block.getPreviousSibling();
+            block.remove();
+            if ($isElementNode(previous))
+                previous.selectEnd();
+            return true;
+        }
+        const container = $findMatchingParent(a, $isLayoutContainerNode);
+        if (container)
+            container.remove();
+        else {
+            a.remove();
+            b.remove();
+        }
+        const remaining = $getCouplets(block);
+        const previousCouplet = remaining[coupletIndex - 1] ?? remaining[0];
+        previousCouplet?.[1].selectEnd();
         return true;
     }
-    const container = $findMatchingParent(a, $isLayoutContainerNode);
-    if (container)
-        container.remove();
-    else {
-        a.remove();
-        b.remove();
-    }
-    const remaining = $getCouplets(block);
-    const previousCouplet = remaining[position.coupletIndex - 1] ?? remaining[0];
-    previousCouplet?.[1].selectEnd();
+    const previousLine = misraIndex === 1 ? a : couplets[coupletIndex - 1]?.[1];
+    previousLine?.selectEnd();
+    return true;
+}
+/**
+ * Forward Delete at the end of a misra never merges the next line into it, for
+ * the same reason as $deletePoetryOnBackspace: the caret moves to the start of
+ * the next line instead. Other caret positions fall through to normal handling.
+ */
+export function $deletePoetryForward() {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection) || !selection.isCollapsed())
+        return false;
+    const block = $getPoetryBlockFromSelection();
+    if (!block)
+        return false;
+    const couplets = $getCouplets(block);
+    const position = $findCoupletPosition(couplets, selection.anchor.getNode());
+    if (!position)
+        return false;
+    const { coupletIndex, misraIndex } = position;
+    const misra = couplets[coupletIndex][misraIndex];
+    if (!$isPointAt(misra, selection.anchor, true))
+        return false;
+    const nextLine = misraIndex === 0 ? couplets[coupletIndex][1] : couplets[coupletIndex + 1]?.[0];
+    nextLine?.selectStart();
     return true;
 }
 /**
@@ -347,3 +385,97 @@ export function $adjustPoetrySpacing(step) {
     block.setSpacing(next);
     return true;
 }
+/** Steps the caret's two-column gutter one notch wider (+1) or narrower (-1);
+ * clamps at either end. */
+export function $adjustPoetryGutter(step) {
+    const block = $getPoetryBlockFromSelection();
+    if (!block)
+        return false;
+    const index = POETRY_GUTTERS.indexOf(block.getGutter());
+    const next = POETRY_GUTTERS[Math.min(POETRY_GUTTERS.length - 1, Math.max(0, index + step))];
+    block.setGutter(next);
+    return true;
+}
+/** Steps the caret's staggered couplet width one notch narrower (-1) or wider
+ * (+1); clamps at either end. */
+export function $adjustPoetryStagger(step) {
+    const block = $getPoetryBlockFromSelection();
+    if (!block)
+        return false;
+    const index = POETRY_STAGGERS.indexOf(block.getStagger());
+    const next = POETRY_STAGGERS[Math.min(POETRY_STAGGERS.length - 1, Math.max(0, index + step))];
+    block.setStagger(next);
+    return true;
+}
+/** A centered couplet is a two-column row holding both misras in one item
+ * (a single-item row), rather than one item per misra. */
+function $isCoupletRowCentered(row) {
+    return row.getChildren().filter($isLayoutItemNode).length === 1;
+}
+function $findCoupletRow(couplet) {
+    return $findMatchingParent(couplet[0], $isLayoutContainerNode);
+}
+/** Whether the couplet the caret is in is centered, or null outside a
+ * two-column poetry block (centering only applies there). */
+export function $getCoupletCenteredFromSelection() {
+    const block = $getPoetryBlockFromSelection();
+    if (!block || block.getLayout() !== 'two-column')
+        return null;
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+        return null;
+    const couplets = $getCouplets(block);
+    const position = $findCoupletPosition(couplets, selection.anchor.getNode());
+    if (!position)
+        return null;
+    const row = $findCoupletRow(couplets[position.coupletIndex]);
+    return row ? $isCoupletRowCentered(row) : false;
+}
+/** Centers (or un-centers) the caret's couplet within a two-column block by
+ * rebuilding its row around the same two misra paragraphs. */
+export function $setCoupletCentered(centered) {
+    const block = $getPoetryBlockFromSelection();
+    if (!block || block.getLayout() !== 'two-column')
+        return false;
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+        return false;
+    const couplets = $getCouplets(block);
+    const position = $findCoupletPosition(couplets, selection.anchor.getNode());
+    if (!position)
+        return false;
+    const couplet = couplets[position.coupletIndex];
+    const row = $findCoupletRow(couplet);
+    if (!row || $isCoupletRowCentered(row) === centered)
+        return true;
+    const [a, b] = couplet;
+    const newRow = $createLayoutContainerNode(centered ? '1fr' : 'repeat(2, 1fr)');
+    if (centered) {
+        newRow.append($createLayoutItemNode().append(a, b));
+    }
+    else {
+        newRow.append($createLayoutItemNode().append(a), $createLayoutItemNode().append(b));
+    }
+    row.insertAfter(newRow);
+    row.remove();
+    a.selectStart();
+    return true;
+}
+/** Removes the whole poetry block the caret is in, including every couplet. */
+export function $deletePoetryBlock() {
+    const block = $getPoetryBlockFromSelection();
+    if (!block)
+        return false;
+    block.remove();
+    return true;
+}
+/** Single-column blocks pair their paragraphs into couplets, so a line left
+ * without a partner (from pasted or imported content) would be invisible to
+ * the couplet logic. Give it an empty partner instead, so every line belongs
+ * to a couplet and can be deleted like any other. */
+export function $completeSingleCoupletBlock(node) {
+    if (node.getLayout() === 'two-column')
+        return;
+    if (node.getChildrenSize() % 2 === 1)
+        node.append($createParagraphNode());
+}

package/dist/components/FindReplaceBar.d.ts

@@ -0,0 +1,8 @@
+import type { Strings } from '../i18n/strings.js';
+/** Find-and-replace controls shown above the canvas. Matches are recomputed
+ * from the document on every action, so edits made in between are respected. */
+export declare function FindReplaceBar({ strings, onClose }: {
+    strings: Strings;
+    onClose: () => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=FindReplaceBar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FindReplaceBar.d.ts","sourceRoot":"","sources":["../../src/components/FindReplaceBar.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAG/C;gFACgF;AAChF,wBAAgB,cAAc,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,+BA2F7F"}

package/dist/components/FindReplaceBar.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { IconX } from '@tabler/icons-react';
+import { $findMatches, $replaceAll, $replaceMatch, $selectMatch } from '../find/findReplaceActions.js';
+/** Find-and-replace controls shown above the canvas. Matches are recomputed
+ * from the document on every action, so edits made in between are respected. */
+export function FindReplaceBar({ strings, onClose }) {
+    const [editor] = useLexicalComposerContext();
+    const t = strings.findReplace;
+    const [query, setQuery] = useState('');
+    const [replacement, setReplacement] = useState('');
+    const [index, setIndex] = useState(0);
+    const [count, setCount] = useState(0);
+    // Runs `action` against the current matches and returns the new count, then
+    // syncs the index and selection. `discrete` makes the update commit before
+    // the next read, so the count reflects this action's changes.
+    const run = (action) => {
+        let result = { nextIndex: 0, matches: [] };
+        editor.update(() => {
+            result = action($findMatches(query));
+            if (result.matches[result.nextIndex])
+                $selectMatch(result.matches[result.nextIndex]);
+        }, { discrete: true });
+        setCount(result.matches.length);
+        setIndex(result.nextIndex);
+        const anchor = result.matches[result.nextIndex];
+        if (anchor)
+            editor.getElementByKey(anchor.anchorKey)?.scrollIntoView({ block: 'center' });
+    };
+    useEffect(() => {
+        run((matches) => ({ nextIndex: 0, matches }));
+        // Re-run when the query changes; `run` closes over it.
+    }, [query]);
+    const step = (delta) => run((matches) => ({
+        matches,
+        nextIndex: matches.length === 0 ? 0 : (index + delta + matches.length) % matches.length,
+    }));
+    const replaceCurrent = () => run((matches) => {
+        const match = matches[index];
+        if (match)
+            $replaceMatch(match, replacement);
+        const after = $findMatches(query);
+        return { matches: after, nextIndex: Math.min(index, Math.max(0, after.length - 1)) };
+    });
+    const replaceEverything = () => run(() => {
+        $replaceAll(query, replacement);
+        return { matches: $findMatches(query), nextIndex: 0 };
+    });
+    const status = query === '' ? '' : count === 0 ? t.noMatches : `${index + 1} / ${count}`;
+    return (_jsxs("div", { className: "likhari-find-bar", role: "search", children: [_jsx("input", { "aria-label": t.find, placeholder: t.findPlaceholder, value: query, onChange: (e) => setQuery(e.target.value), onKeyDown: (e) => {
+                    if (e.key === 'Enter')
+                        step(e.shiftKey ? -1 : 1);
+                    if (e.key === 'Escape')
+                        onClose();
+                } }), _jsx("span", { className: "likhari-find-status", "aria-live": "polite", children: status }), _jsx("button", { type: "button", onClick: () => step(-1), disabled: count === 0, children: t.previous }), _jsx("button", { type: "button", onClick: () => step(1), disabled: count === 0, children: t.next }), _jsx("input", { "aria-label": t.replace, placeholder: t.replacePlaceholder, value: replacement, onChange: (e) => setReplacement(e.target.value) }), _jsx("button", { type: "button", onClick: replaceCurrent, disabled: count === 0, children: t.replaceOne }), _jsx("button", { type: "button", onClick: replaceEverything, disabled: count === 0, children: t.replaceAll }), _jsx("button", { type: "button", className: "likhari-find-close", onClick: onClose, "aria-label": t.close, title: t.close, children: _jsx(IconX, { size: 16, stroke: 1.75 }) })] }));
+}

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

@@ -1 +1 @@
-{"version":3,"file":"Toolbar.d.ts","sourceRoot":"","sources":["../../src/components/Toolbar.tsx"],"names":[],"mappings":"AAuEA,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;AAsfvD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,2BAA2B,CAAC;IACpC,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,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAkC,EAAE,SAAiB,EAAE,MAAa,EAAE,MAAM,EAAE,EAAE,YAAY,+BA+jCxJ"}
+{"version":3,"file":"Toolbar.d.ts","sourceRoot":"","sources":["../../src/components/Toolbar.tsx"],"names":[],"mappings":"AAsFA,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+gBvD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,2BAA2B,CAAC;IACpC,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,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAkC,EAAE,SAAiB,EAAE,MAAa,EAAE,MAAM,EAAE,EAAE,YAAY,+BAwkCxJ"}

package/dist/components/Toolbar.js

@@ -8,14 +8,15 @@ import { $createParagraphNode } from 'lexical';
 import { $createHeadingNode, $createQuoteNode, $isHeadingNode, $isQuoteNode } from '@lexical/rich-text';
 import { $isListNode, INSERT_CHECK_LIST_COMMAND, INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, REMOVE_LIST_COMMAND, } from '@lexical/list';
 import { $findMatchingParent, $insertNodeToNearestRoot } from '@lexical/utils';
+import { FindReplaceBar } from './FindReplaceBar.js';
 import { INSERT_HORIZONTAL_RULE_COMMAND } from '@lexical/react/LexicalHorizontalRuleNode';
 import { ImageDialog } from '../image/ImageDialog.js';
 import { $createImageNode } from '../image/ImageNode.js';
 import { INSERT_PAGE_BREAK_COMMAND } from '../blocks/PageBreakNode.js';
 import { INSERT_LAYOUT_COMMAND } from '../blocks/LayoutNode.js';
 import { INSERT_FOOTNOTE_COMMAND } from '../blocks/FootnoteNode.js';
-import { $isPoetryBlockNode } from '../blocks/PoetryNode.js';
-import { $adjustPoetrySpacing, $deletePoetryCouplet, $getPoetryBlockFromSelection, $insertCoupletRelativeToSelection, $setPoetryLayout, } from '../blocks/poetryActions.js';
+import { $isPoetryBlockNode, POETRY_GUTTERS, POETRY_SPACINGS, POETRY_STAGGERS, } from '../blocks/PoetryNode.js';
+import { $adjustPoetryGutter, $getCoupletCenteredFromSelection, $setCoupletCentered, $adjustPoetryStagger, $adjustPoetrySpacing, $deletePoetryBlock, $deletePoetryCouplet, $getPoetryBlockFromSelection, $insertCoupletRelativeToSelection, $setPoetryLayout, } from '../blocks/poetryActions.js';
 import { INSERT_POETRY_COUPLET_COMMAND } from '../plugins/PoetryPlugin.js';
 import { TableDialog } from './TableDialog.js';
 import { LayoutDialog } from './LayoutDialog.js';
@@ -29,7 +30,7 @@ import { CANVAS_FONT_DEFAULTS, DEFAULT_FONT_OPTIONS, FONT_SIZES_PX } from '../fo
 import { setStyleProperty } from '../utils/style.js';
 import { useStrings } from '../i18n/useStrings.js';
 import { usePortalTarget } from '../PortalTargetContext.js';
-import { IconAbc, IconAlignCenter, IconAlignJustified, IconAlignLeft, IconAlignRight, IconArrowBackUp, IconArrowForwardUp, IconBold, IconClearFormatting, IconDeviceFloppy, IconDots, IconHistory, IconExternalLink, IconFeather, IconH1, IconH2, IconH3, IconH4, IconH5, IconH6, IconIndentDecrease, IconIndentIncrease, IconItalic, IconLetterCase, IconLetterCaseLower, IconLetterCaseUpper, IconLink, IconLinkOff, IconList, IconListCheck, IconListNumbers, IconPageBreak, IconPencil, IconPhoto, IconPilcrow, IconQuote, IconSeparatorHorizontal, IconSparkles, IconStrikethrough, IconSubscript, IconSuperscript, IconArrowMergeBoth, IconArrowsSplit2, IconColumnInsertLeft, IconColumnInsertRight, IconColumnRemove, IconColumns, IconColumns1, IconColumns2, IconNumber1Small, IconRowInsertBottom, IconRowInsertTop, IconRowRemove, IconArrowsMaximize, IconArrowsMinimize, IconTable, IconTableMinus, IconTrash, IconTableOptions, IconTextSize, IconTypography, IconUnderline, IconWand, } from '@tabler/icons-react';
+import { IconAbc, IconAlignCenter, IconAlignJustified, IconAlignLeft, IconAlignRight, IconArrowBackUp, IconArrowForwardUp, IconBold, IconClearFormatting, IconDeviceFloppy, IconDots, IconHistory, IconExternalLink, IconFeather, IconH1, IconH2, IconH3, IconH4, IconH5, IconH6, IconIndentDecrease, IconIndentIncrease, IconItalic, IconLetterCase, IconLetterCaseLower, IconLetterCaseUpper, IconLink, IconLinkOff, IconList, IconListCheck, IconListNumbers, IconPageBreak, IconPencil, IconPhoto, IconPilcrow, IconQuote, IconSeparatorHorizontal, IconSparkles, IconStrikethrough, IconSubscript, IconSuperscript, IconArrowMergeBoth, IconArrowsSplit2, IconColumnInsertLeft, IconColumnInsertRight, IconColumnRemove, IconColumns, IconSearch, IconColumns1, IconColumns2, IconNumber1Small, IconRowInsertBottom, IconRowInsertTop, IconRowRemove, IconArrowsMaximize, IconArrowsMinimize, IconArrowsShuffle, IconTable, IconTableMinus, IconTrash, IconTableOptions, IconTextSize, IconTypography, IconUnderline, IconWand, } from '@tabler/icons-react';
 /** Sentinel for "no inline style": Lexical returns the default it is given when
  * the selection has none, so this tells "unstyled" (show the canvas default)
  * apart from "styled with a value the dropdown doesn't list" (show nothing). */
@@ -50,7 +51,8 @@ const INITIAL_STATE = {
     canUnmergeCell: false,
     inPoetry: false,
     poetryLayout: 'single',
-    poetryAlign: 'justify',
+    poetryScale: { spacing: 'normal', gutter: 'normal', stagger: 'normal' },
+    poetryCentered: false,
     canUndo: false,
     canRedo: false,
 };
@@ -162,16 +164,14 @@ function TableMenuItems({ strings, direction, rows, columns, canMergeCells, canU
     };
     return (_jsxs(_Fragment, { children: [_jsx(Menu.Label, { children: t.menuLabel }), item(IconRowInsertTop, manyRows ? t.insertRowsBefore : t.insertRowBefore, () => $insertTableRows(false)), item(IconRowInsertBottom, manyRows ? t.insertRowsAfter : t.insertRowAfter, () => $insertTableRows(true)), item(rtl ? IconColumnInsertRight : IconColumnInsertLeft, manyColumns ? t.insertColumnsBefore : t.insertColumnBefore, () => $insertTableColumns(false)), item(rtl ? IconColumnInsertLeft : IconColumnInsertRight, manyColumns ? t.insertColumnsAfter : t.insertColumnAfter, () => $insertTableColumns(true)), (canMergeCells || canUnmergeCell) && _jsx(Menu.Divider, {}), canMergeCells && item(IconArrowMergeBoth, t.mergeCells, $mergeTableCells), canUnmergeCell && item(IconArrowsSplit2, t.unmergeCell, $unmergeTableCell), _jsx(Menu.Divider, {}), item(IconRowRemove, manyRows ? t.deleteRows : t.deleteRow, $deleteTableRows), item(IconColumnRemove, manyColumns ? t.deleteColumns : t.deleteColumn, $deleteTableColumns), item(IconTableMinus, t.deleteTable, $deleteTable, 'red')] }));
 }
-/** The poetry couplet menu's contents — layout (single/two-column) and
- * literal alignment, both per-instance overrides (requirements doc §4.11:
- * "set per CoupletNode, not inherited from a document-wide setting"), plus
- * table-row-style structural actions (insert a couplet above/below the one
- * the caret is in, delete it) — a poetry block is "one object with multiple
- * couplets, add/remove like table rows", so these mirror TableMenuItems'
- * own insert-before/insert-after/delete-row actions. */
-function PoetryMenuItems({ strings, alignIcons, layout, align, onAction, }) {
+/** Whether a one-notch step from `value` stays on the scale — a step that
+ * would fall off either end is disabled rather than silently clamped. */
+function canStep(scale, value, step) {
+    const next = scale.indexOf(value) + step;
+    return next >= 0 && next < scale.length;
+}
+function PoetryMenuItems({ strings, layout, scale, centered, onAction, }) {
     const t = strings.poetryMenu;
-    const a = strings.toolbar.alignOptions;
     const item = (icon, label, action, active = false, color) => {
         const Icon = icon;
         return (_jsx(Menu.Item, { color: color, disabled: active, leftSection: _jsx(Icon, { size: ICON_SIZE, stroke: ICON_STROKE }), onMouseDown: (e) => e.preventDefault(), onClick: onAction(action), children: label }));
@@ -181,10 +181,7 @@ function PoetryMenuItems({ strings, alignIcons, layout, align, onAction, }) {
         if (node)
             $setPoetryLayout(node, next);
     };
-    const setAlign = (next) => () => {
-        $getPoetryBlockFromSelection()?.setAlign(next);
-    };
-    return (_jsxs(_Fragment, { children: [_jsx(Menu.Label, { children: t.menuLabel }), item(IconColumns1, t.singleColumn, setLayout('single'), layout === 'single'), item(IconColumns2, t.twoColumn, setLayout('two-column'), layout === 'two-column'), _jsx(Menu.Divider, {}), item(alignIcons.justify ?? IconAlignJustified, a.justify, setAlign('justify'), align === 'justify'), item(alignIcons.start ?? IconAlignLeft, a.start, setAlign('start'), align === 'start'), item(IconAlignLeft, a.left, setAlign('left'), align === 'left'), item(IconAlignRight, a.right, setAlign('right'), align === 'right'), _jsx(Menu.Divider, {}), item(IconRowInsertTop, t.insertCoupletBefore, () => $insertCoupletRelativeToSelection('before')), item(IconRowInsertBottom, t.insertCoupletAfter, () => $insertCoupletRelativeToSelection('after')), item(IconArrowsMinimize, t.tighterSpacing, () => $adjustPoetrySpacing(-1)), item(IconArrowsMaximize, t.looserSpacing, () => $adjustPoetrySpacing(1)), item(IconTrash, t.deleteCouplet, $deletePoetryCouplet, false, 'red')] }));
+    return (_jsxs(_Fragment, { children: [_jsx(Menu.Label, { children: t.menuLabel }), item(IconColumns1, t.singleColumn, setLayout('single'), layout === 'single'), item(IconColumns2, t.twoColumn, setLayout('two-column'), layout === 'two-column'), item(IconArrowsShuffle, t.staggered, setLayout('staggered'), layout === 'staggered'), _jsx(Menu.Divider, {}), _jsx(Menu.Divider, {}), item(IconRowInsertTop, t.insertCoupletBefore, () => $insertCoupletRelativeToSelection('before')), item(IconRowInsertBottom, t.insertCoupletAfter, () => $insertCoupletRelativeToSelection('after')), item(IconArrowsMinimize, t.tighterSpacing, () => $adjustPoetrySpacing(-1), !canStep(POETRY_SPACINGS, scale.spacing, -1)), item(IconArrowsMaximize, t.looserSpacing, () => $adjustPoetrySpacing(1), !canStep(POETRY_SPACINGS, scale.spacing, 1)), layout === 'staggered' && (_jsxs(_Fragment, { children: [item(IconArrowsMinimize, t.narrowerCouplets, () => $adjustPoetryStagger(-1), !canStep(POETRY_STAGGERS, scale.stagger, -1)), item(IconArrowsMaximize, t.widerCouplets, () => $adjustPoetryStagger(1), !canStep(POETRY_STAGGERS, scale.stagger, 1))] })), layout === 'two-column' && (_jsxs(_Fragment, { children: [item(IconAlignCenter, centered ? t.uncenterCouplet : t.centerCouplet, () => $setCoupletCentered(!centered)), item(IconColumns2, t.narrowerGutter, () => $adjustPoetryGutter(-1), !canStep(POETRY_GUTTERS, scale.gutter, -1)), item(IconColumns2, t.widerGutter, () => $adjustPoetryGutter(1), !canStep(POETRY_GUTTERS, scale.gutter, 1))] })), item(IconTrash, t.deleteCouplet, $deletePoetryCouplet, false, 'red'), item(IconTrash, t.deletePoetry, $deletePoetryBlock, false, 'red')] }));
 }
 export function Toolbar({ config, onSave, isDirty, showSave, fontOptions = DEFAULT_FONT_OPTIONS, direction = 'ltr', locale = 'en', drafts }) {
     const [editor] = useLexicalComposerContext();
@@ -246,7 +243,10 @@ export function Toolbar({ config, onSave, isDirty, showSave, fontOptions = DEFAU
             // node method (getFormatType() included) must not be deferred into it.
             const elementFormat = ($isElementNode(element) ? element.getFormatType() : 'start') || 'start';
             const poetryLayout = poetryBlock?.getLayout();
-            const poetryAlign = poetryBlock?.getAlign();
+            const poetryCentered = $getCoupletCenteredFromSelection();
+            const poetryScale = poetryBlock
+                ? { spacing: poetryBlock.getSpacing(), gutter: poetryBlock.getGutter(), stagger: poetryBlock.getStagger() }
+                : null;
             setState((s) => ({
                 ...s,
                 blockType,
@@ -264,7 +264,8 @@ export function Toolbar({ config, onSave, isDirty, showSave, fontOptions = DEFAU
                 canUnmergeCell,
                 inPoetry: poetryBlock !== null,
                 poetryLayout: poetryLayout ?? s.poetryLayout,
-                poetryAlign: poetryAlign ?? s.poetryAlign,
+                poetryScale: poetryScale ?? s.poetryScale,
+                poetryCentered: poetryCentered ?? false,
             }));
         });
     }, [editor]);
@@ -385,6 +386,7 @@ export function Toolbar({ config, onSave, isDirty, showSave, fontOptions = DEFAU
         closeTableDialog();
     };
     const [layoutDialogOpen, setLayoutDialogOpen] = useState(false);
+    const [findOpen, setFindOpen] = useState(false);
     const openLayoutDialog = () => {
         snapshotSelection();
         setLayoutDialogOpen(true);
@@ -808,9 +810,9 @@ export function Toolbar({ config, onSave, isDirty, showSave, fontOptions = DEFAU
                                 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.poetry.enabled && locale !== 'en' && (_jsx(ToolbarButton, { icon: IconFeather, title: strings.toolbar.insertPoetryCouplet, onClick: () => editor.dispatchCommand(INSERT_POETRY_COUPLET_COMMAND, { layout: config.poetry.defaultLayout, align: 'justify' }) }))] }, "stubInsert")),
+        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: () => setFindOpen((v) => !v) })), 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, alignIcons: ALIGN_ICONS, layout: state.poetryLayout, align: state.poetryAlign, onAction: runMenuAction }) })] }) }, "poetryActions")),
+        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(StubButton, { icon: IconWand, title: strings.toolbar.autocorrect, comingSoon: strings.toolbar.comingSoon }), config.language.textCleanup && _jsx(StubButton, { icon: IconSparkles, title: strings.toolbar.textCleanup, comingSoon: strings.toolbar.comingSoon }), config.language.spellCheck && _jsx(StubButton, { icon: IconAbc, title: strings.toolbar.spellChecker, comingSoon: strings.toolbar.comingSoon })] }, "language")),
     ];
     return (_jsxs("div", { className: "likhari-toolbar", role: "toolbar", "aria-label": strings.toolbar.ariaLabel, ref: toolbarContainerRef, children: [fixedGroups, movableGroups
@@ -829,7 +831,7 @@ export function Toolbar({ config, onSave, isDirty, showSave, fontOptions = DEFAU
                 }, position: "bottom-start", withinPortal: true, portalProps: { target: portalTarget }, shadow: "sm", width: 240, children: [_jsx(Menu.Target, { children: _jsx("span", { "aria-hidden": "true", style: { position: 'fixed', left: tableContext?.x ?? -9999, top: tableContext?.y ?? -9999, width: 1, height: 1, pointerEvents: 'none' } }) }), _jsx(Menu.Dropdown, { children: _jsx(TableMenuItems, { strings: strings, direction: direction, rows: tableContext?.rows ?? 1, columns: tableContext?.columns ?? 1, canMergeCells: state.canMergeCells, canUnmergeCell: state.canUnmergeCell, onAction: runMenuAction }) })] })), config.poetry.enabled && (_jsxs(Menu, { opened: poetryContext !== null, onChange: (opened) => {
                     if (!opened)
                         setPoetryContext(null);
-                }, position: "bottom-start", withinPortal: true, portalProps: { target: portalTarget }, shadow: "sm", width: 200, children: [_jsx(Menu.Target, { children: _jsx("span", { "aria-hidden": "true", style: { position: 'fixed', left: poetryContext?.x ?? -9999, top: poetryContext?.y ?? -9999, width: 1, height: 1, pointerEvents: 'none' } }) }), _jsx(Menu.Dropdown, { children: _jsx(PoetryMenuItems, { strings: strings, alignIcons: ALIGN_ICONS, layout: state.poetryLayout, align: state.poetryAlign, onAction: runMenuAction }) })] })), _jsxs("div", { "aria-hidden": "true", ref: toolbarMeasureRef, style: {
+                }, position: "bottom-start", withinPortal: true, portalProps: { target: portalTarget }, shadow: "sm", width: 200, children: [_jsx(Menu.Target, { children: _jsx("span", { "aria-hidden": "true", style: { position: 'fixed', left: poetryContext?.x ?? -9999, top: poetryContext?.y ?? -9999, width: 1, height: 1, pointerEvents: 'none' } }) }), _jsx(Menu.Dropdown, { children: _jsx(PoetryMenuItems, { strings: strings, layout: state.poetryLayout, scale: state.poetryScale, centered: state.poetryCentered, onAction: runMenuAction }) })] })), _jsxs("div", { "aria-hidden": "true", ref: toolbarMeasureRef, style: {
                     position: 'absolute',
                     visibility: 'hidden',
                     pointerEvents: 'none',
@@ -838,5 +840,5 @@ export function Toolbar({ config, onSave, isDirty, showSave, fontOptions = DEFAU
                     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 })] }));
+                }, 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.findReplace && findOpen && _jsx(FindReplaceBar, { strings: strings, onClose: () => setFindOpen(false) }), 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/find/findReplaceActions.d.ts

@@ -0,0 +1,23 @@
+/** A match as a Lexical selection range: start and end points, each in a text node. */
+export interface FindMatch {
+    anchorKey: string;
+    anchorOffset: number;
+    focusKey: string;
+    focusOffset: number;
+}
+/** Every non-overlapping occurrence of `query` in the document, case-sensitive. */
+export declare function $findMatches(query: string): FindMatch[];
+/** Makes the match the editor's selection, so it's highlighted and scrolled to. */
+export declare function $selectMatch(match: FindMatch): void;
+/**
+ * Replaces one match, keeping the formatting of the text around it. The
+ * replacement takes the formatting of the match's first character.
+ */
+export declare function $replaceMatch(match: FindMatch, replacement: string): void;
+/**
+ * Replaces every match. Walks from the last match to the first, so each
+ * replacement leaves the positions of the matches before it unchanged.
+ * Returns how many were replaced.
+ */
+export declare function $replaceAll(query: string, replacement: string): number;
+//# sourceMappingURL=findReplaceActions.d.ts.map

package/dist/find/findReplaceActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findReplaceActions.d.ts","sourceRoot":"","sources":["../../src/find/findReplaceActions.ts"],"names":[],"mappings":"AAEA,uFAAuF;AACvF,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAgCD,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,CAcvD;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAKnD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAMzE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAItE"}

package/dist/find/findReplaceActions.js

@@ -0,0 +1,81 @@
+import { $createRangeSelection, $getRoot, $getSelection, $isRangeSelection, $setSelection } from 'lexical';
+/**
+ * Text nodes grouped by their parent, in document order. A match is searched
+ * for within one parent only, so it never spans two paragraphs or table
+ * cells, but it can span the several text nodes that formatting splits a
+ * paragraph into.
+ */
+function $textGroups() {
+    const groups = new Map();
+    for (const node of $getRoot().getAllTextNodes()) {
+        const parentKey = node.getParentOrThrow().getKey();
+        const group = groups.get(parentKey);
+        if (group)
+            group.push(node);
+        else
+            groups.set(parentKey, [node]);
+    }
+    return [...groups.values()];
+}
+/** The text node and offset that a character index in a group falls in. */
+function $locate(group, index, end) {
+    let start = 0;
+    for (const node of group) {
+        const length = node.getTextContent().length;
+        const inside = end ? index > start && index <= start + length : index >= start && index < start + length;
+        if (inside)
+            return { key: node.getKey(), offset: index - start };
+        start += length;
+    }
+    const last = group[group.length - 1];
+    return { key: last.getKey(), offset: last.getTextContent().length };
+}
+/** Every non-overlapping occurrence of `query` in the document, case-sensitive. */
+export function $findMatches(query) {
+    if (query === '')
+        return [];
+    const matches = [];
+    for (const group of $textGroups()) {
+        const text = group.map((node) => node.getTextContent()).join('');
+        let index = text.indexOf(query);
+        while (index !== -1) {
+            const start = $locate(group, index, false);
+            const end = $locate(group, index + query.length, true);
+            matches.push({ anchorKey: start.key, anchorOffset: start.offset, focusKey: end.key, focusOffset: end.offset });
+            index = text.indexOf(query, index + query.length);
+        }
+    }
+    return matches;
+}
+/** Makes the match the editor's selection, so it's highlighted and scrolled to. */
+export function $selectMatch(match) {
+    const selection = $createRangeSelection();
+    selection.anchor.set(match.anchorKey, match.anchorOffset, 'text');
+    selection.focus.set(match.focusKey, match.focusOffset, 'text');
+    $setSelection(selection);
+}
+/**
+ * Replaces one match, keeping the formatting of the text around it. The
+ * replacement takes the formatting of the match's first character.
+ */
+export function $replaceMatch(match, replacement) {
+    $selectMatch(match);
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+        return;
+    if (replacement === '')
+        selection.removeText();
+    else
+        selection.insertText(replacement);
+}
+/**
+ * Replaces every match. Walks from the last match to the first, so each
+ * replacement leaves the positions of the matches before it unchanged.
+ * Returns how many were replaced.
+ */
+export function $replaceAll(query, replacement) {
+    const matches = $findMatches(query);
+    for (let i = matches.length - 1; i >= 0; i--)
+        $replaceMatch(matches[i], replacement);
+    return matches.length;
+}