@rivet-health/design-system 40.44.0 → 40.44.2

package/esm2022/lib/input/mentions-input/mentions-input.component.mjs

@@ -0,0 +1,745 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewChild, ViewEncapsulation, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../overlay/callout/callout.component";
+const ZWS = '​';
+const ZWS_REGEX = /​/g;
+/**
+ * A rich text input that supports `@`-mentions inside a `contenteditable` div.
+ *
+ * ## Data Model
+ * - **Input/Output**: `ContentItem[]` (mentions, text, newlines)
+ *
+ * ## DOM Invariant
+ * Every mention `<span data-type="mention" contenteditable="false">` is wrapped
+ * by exactly one zero-width-space (ZWS) text node before and after it. ZWS gives
+ * the cursor a valid landing spot adjacent to a non-editable element. The
+ * invariant is established at render time and re-established by
+ * `normalizeMentionPadding()` after any DOM-mutating operation.
+ *
+ * ## Copy/Paste
+ * - **Copy**: `range.cloneContents()` preserves `data-*` attributes (only the
+ *   browser's default copy path strips them). We override copy, serialize the
+ *   clone ourselves, and strip ZWS from the output.
+ * - **Paste**: HTML paths look for `data-type="mention"` spans and rebuild
+ *   them; otherwise plaintext fallback.
+ */
+export class MentionsInputComponent {
+    constructor(cdr) {
+        this.cdr = cdr;
+        this.content = [];
+        this.users = [];
+        this.readonly = false;
+        this.placeholder = 'Add a comment';
+        this.contentChange = new EventEmitter();
+        this.mentionsVisible = false;
+        this.mentionSearchText = '';
+        this.mentionAnchor = null;
+        this.selectedUserIndex = 0;
+        this.savedRange = null;
+    }
+    ngAfterViewInit() {
+        this.renderContent();
+    }
+    //DAHNE NOTE - ngOnChanges is called whenever any @Input() property changes, where the changed input contains information about those changes
+    //So if @Input() content changes and it's not the first change (the first render is handled by ngAfterViewInit()), we render the content
+    ngOnChanges(changes) {
+        if (changes['content'] && !changes['content'].firstChange) {
+            this.renderContent();
+        }
+    }
+    renderContent() {
+        //This is necessary because the @ViewChild reference isn't available until after the view initializes
+        if (!this.inputElement?.nativeElement) {
+            return;
+        }
+        const html = this.content
+            .map(item => {
+            const itemHtml = MentionsInputComponent.contentItemToHtml(item, this.readonly);
+            return item.type === 'mention' ? `${ZWS}${itemHtml}${ZWS}` : itemHtml;
+        })
+            .join('');
+        this.inputElement.nativeElement.innerHTML = html;
+    }
+    static contentItemToHtml(item, readonly) {
+        switch (item.type) {
+            //DAHNE TODO - maybe we escape HTML here too? Although I don't think it will be possible for users to input an XSS attack in item.name
+            case 'mention':
+                return `<span class="${readonly ? 'readonly-mention' : 'mention'}" data-id="${item.id}" data-type="mention" contenteditable="false">@${MentionsInputComponent.escapeHtml(item.name)}</span>`;
+            case 'text':
+                return MentionsInputComponent.escapeHtml(item.text);
+            case 'newline':
+                return '<br>';
+        }
+    }
+    static escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+    // ─── Event handlers ───────────────────────────────────────────────────
+    onInput() {
+        this.normalizeMentionPadding();
+        this.checkForMentionTrigger();
+        this.emitContentChange();
+    }
+    onKeyDown(event) {
+        if (this.mentionsVisible) {
+            this.handleMentionsDropdownNav(event);
+            return;
+        }
+        // Word/line jump: native behavior.
+        if (event.metaKey || event.ctrlKey) {
+            return;
+        }
+        if (event.key === 'ArrowLeft' || event.key === 'ArrowRight') {
+            const direction = event.key === 'ArrowLeft' ? 'before' : 'after';
+            const mention = this.findMentionAdjacentToCursor(direction);
+            if (mention) {
+                event.preventDefault();
+                if (event.shiftKey) {
+                    this.extendSelectionAcrossMention(mention, direction);
+                }
+                else {
+                    this.placeCursorAdjacentToMention(mention, direction);
+                }
+            }
+            return;
+        }
+        if (event.key === 'Backspace' || event.key === 'Delete') {
+            const direction = event.key === 'Backspace' ? 'before' : 'after';
+            const mention = this.findMentionAdjacentToCursor(direction);
+            if (mention) {
+                event.preventDefault();
+                this.removeMention(mention);
+                this.emitContentChange();
+                return;
+            }
+            if (event.key === 'Backspace') {
+                const br = this.findBrAdjacentToCursor();
+                if (br) {
+                    event.preventDefault();
+                    br.remove();
+                    this.emitContentChange();
+                }
+            }
+            return;
+        }
+        //Handle newlines when mentions aren't visible
+        if (event.key === 'Enter') {
+            event.preventDefault();
+            this.insertLineBreak();
+            this.emitContentChange();
+        }
+    }
+    onPaste(event) {
+        event.preventDefault();
+        if (!event.clipboardData) {
+            return;
+        }
+        //Look for HTML first
+        const html = event.clipboardData.getData('text/html');
+        const plainText = event.clipboardData.getData('text/plain');
+        const nodes = html && html.includes('data-type="mention"')
+            ? this.parsePastedHtml(html)
+            : this.plainTextToNodes(plainText);
+        this.insertNodesAtCursor(nodes);
+        this.normalizeMentionPadding();
+        this.emitContentChange();
+    }
+    // The browser strips data-* attributes during default copy serialization, but
+    // range.cloneContents() preserves them. We serialize the clone ourselves and
+    // strip ZWS so it doesn't leak into the clipboard.
+    onCopy(event) {
+        const selection = window.getSelection();
+        if (!selection?.rangeCount) {
+            return;
+        }
+        event.preventDefault();
+        const div = document.createElement('div');
+        div.appendChild(selection.getRangeAt(0).cloneContents());
+        const html = div.innerHTML.replace(ZWS_REGEX, '');
+        const text = (div.textContent || '').replace(ZWS_REGEX, '');
+        event.clipboardData?.setData('text/html', html);
+        event.clipboardData?.setData('text/plain', text);
+    }
+    onCut(event) {
+        this.onCopy(event);
+        const selection = window.getSelection();
+        if (!selection?.rangeCount) {
+            return;
+        }
+        selection.getRangeAt(0).deleteContents();
+        this.normalizeMentionPadding();
+        this.emitContentChange();
+    }
+    // ─── Mention helpers ───────────────────────────────────────────────────
+    static isMention(node) {
+        return (!!node &&
+            node.nodeType === Node.ELEMENT_NODE &&
+            node.getAttribute('data-type') === 'mention');
+    }
+    static isZws(node) {
+        return (!!node &&
+            node.nodeType === Node.TEXT_NODE &&
+            (node.textContent || '').replace(ZWS_REGEX, '') === '');
+    }
+    // Resolve the node logically adjacent to (container, offset) in the given
+    // direction, transparently skipping any ZWS-only text nodes in between.
+    resolveAdjacentNode(container, offset, direction) {
+        let candidate = null;
+        if (container.nodeType === Node.TEXT_NODE) {
+            const length = (container.textContent || '').length;
+            const atBoundary = MentionsInputComponent.isZws(container) ||
+                (direction === 'before' ? offset === 0 : offset === length);
+            if (!atBoundary) {
+                return null;
+            }
+            candidate =
+                direction === 'before'
+                    ? container.previousSibling
+                    : container.nextSibling;
+        }
+        else if (container.nodeType === Node.ELEMENT_NODE) {
+            const children = container.childNodes;
+            candidate =
+                direction === 'before' ? children[offset - 1] : children[offset];
+        }
+        while (candidate && MentionsInputComponent.isZws(candidate)) {
+            candidate =
+                direction === 'before'
+                    ? candidate.previousSibling
+                    : candidate.nextSibling;
+        }
+        return candidate;
+    }
+    findMentionAdjacentToCursor(direction) {
+        const selection = window.getSelection();
+        if (!selection?.isCollapsed || !selection.rangeCount) {
+            return null;
+        }
+        const range = selection.getRangeAt(0);
+        const node = this.resolveAdjacentNode(range.startContainer, range.startOffset, direction);
+        return MentionsInputComponent.isMention(node) ? node : null;
+    }
+    findBrAdjacentToCursor() {
+        const selection = window.getSelection();
+        if (!selection?.isCollapsed || !selection.rangeCount) {
+            return null;
+        }
+        const range = selection.getRangeAt(0);
+        const node = this.resolveAdjacentNode(range.startContainer, range.startOffset, 'before');
+        return node?.nodeName === 'BR' ? node : null;
+    }
+    extendSelectionAcrossMention(mention, direction) {
+        const selection = window.getSelection();
+        const parent = mention.parentNode;
+        if (!selection || !parent) {
+            return;
+        }
+        const index = Array.from(parent.childNodes).indexOf(mention);
+        selection.extend(parent, direction === 'before' ? index : index + 1);
+    }
+    placeCursorAdjacentToMention(mention, side) {
+        const parent = mention.parentNode;
+        if (!parent) {
+            return;
+        }
+        const sibling = side === 'before' ? mention.previousSibling : mention.nextSibling;
+        let zws;
+        if (sibling && MentionsInputComponent.isZws(sibling)) {
+            zws = sibling;
+        }
+        else {
+            zws = document.createTextNode(ZWS);
+            parent.insertBefore(zws, side === 'before' ? mention : mention.nextSibling);
+        }
+        const range = document.createRange();
+        range.setStart(zws, side === 'before' ? (zws.textContent || '').length : 0);
+        range.collapse(true);
+        const selection = window.getSelection();
+        selection?.removeAllRanges();
+        selection?.addRange(range);
+    }
+    removeMention(mention) {
+        const parent = mention.parentNode;
+        if (!parent) {
+            return;
+        }
+        // Empty text-node anchor preserves cursor position through the removal.
+        const anchor = document.createTextNode('');
+        parent.insertBefore(anchor, mention);
+        const prev = mention.previousSibling;
+        const next = mention.nextSibling;
+        if (prev && MentionsInputComponent.isZws(prev)) {
+            prev.remove();
+        }
+        if (next && MentionsInputComponent.isZws(next)) {
+            next.remove();
+        }
+        mention.remove();
+        const range = document.createRange();
+        range.setStart(anchor, 0);
+        range.collapse(true);
+        const selection = window.getSelection();
+        selection?.removeAllRanges();
+        selection?.addRange(range);
+    }
+    // Re-establishes the invariant: every mention has exactly one ZWS text
+    // node immediately before and after it, and there are no orphan ZWS-only
+    // text nodes anywhere else. Run after any operation that may disturb the
+    // tree (typing, paste, cut, delete) so cruft doesn't accumulate across
+    // repeated copy/paste cycles.
+    normalizeMentionPadding() {
+        const root = this.inputElement?.nativeElement;
+        if (!root) {
+            return;
+        }
+        // 1. Ensure each mention has a ZWS pad on both sides.
+        const mentions = Array.from(root.querySelectorAll('span[data-type="mention"]'));
+        for (const m of mentions) {
+            const parent = m.parentNode;
+            if (!parent) {
+                continue;
+            }
+            if (!m.previousSibling ||
+                !MentionsInputComponent.isZws(m.previousSibling)) {
+                parent.insertBefore(document.createTextNode(ZWS), m);
+            }
+            if (!m.nextSibling || !MentionsInputComponent.isZws(m.nextSibling)) {
+                parent.insertBefore(document.createTextNode(ZWS), m.nextSibling);
+            }
+        }
+        // 2. Remove any ZWS-only text node that isn't directly adjacent to a
+        //    mention (orphans from line-break pads, leftover splits from previous
+        //    paste insertions, duplicate pads from accumulated copy/paste cycles).
+        //    Skip a node if the cursor currently lives in it — preserves caret
+        //    position without needing manual restoration.
+        const selection = window.getSelection();
+        const cursorNode = selection?.rangeCount &&
+            root.contains(selection.getRangeAt(0).startContainer)
+            ? selection.getRangeAt(0).startContainer
+            : null;
+        const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, null);
+        const orphans = [];
+        while (walker.nextNode()) {
+            const node = walker.currentNode;
+            if (!MentionsInputComponent.isZws(node) || node === cursorNode) {
+                continue;
+            }
+            const adjacentToMention = MentionsInputComponent.isMention(node.previousSibling) ||
+                MentionsInputComponent.isMention(node.nextSibling);
+            if (!adjacentToMention) {
+                orphans.push(node);
+            }
+        }
+        for (const node of orphans) {
+            node.remove();
+        }
+    }
+    handleMentionsDropdownNav(event) {
+        const filteredUsers = this.getFilteredUsers();
+        if (filteredUsers.length === 0) {
+            this.closeMentions();
+            return;
+        }
+        switch (event.key) {
+            case 'ArrowDown':
+                event.preventDefault();
+                this.selectedUserIndex = Math.min(this.selectedUserIndex + 1, filteredUsers.length - 1);
+                this.cdr.markForCheck();
+                break;
+            case 'ArrowUp':
+                event.preventDefault();
+                this.selectedUserIndex = Math.max(this.selectedUserIndex - 1, 0);
+                this.cdr.markForCheck();
+                break;
+            case 'Enter':
+            case 'Tab':
+                event.preventDefault();
+                if (filteredUsers[this.selectedUserIndex]) {
+                    this.selectUser(filteredUsers[this.selectedUserIndex]);
+                }
+                break;
+            case 'Escape':
+                event.preventDefault();
+                this.closeMentions();
+                break;
+        }
+    }
+    // ─── Insertion ─────────────────────────────────────────────────────────
+    plainTextToNodes(text) {
+        const nodes = [];
+        const lines = text.split('\n');
+        lines.forEach((line, index) => {
+            if (line) {
+                nodes.push(document.createTextNode(line));
+            }
+            if (index < lines.length - 1) {
+                nodes.push(document.createElement('br'));
+            }
+        });
+        return nodes;
+    }
+    // Create a temporary container to parse the HTML
+    parsePastedHtml(html) {
+        // Create a temporary container to parse the HTML
+        const tempContainer = document.createElement('div');
+        tempContainer.innerHTML = html;
+        const nodes = [];
+        const walk = (node) => {
+            if (node.nodeType === Node.ELEMENT_NODE) {
+                const el = node;
+                // DAHNE NOTE - we only want mention spans, br elements, and text
+                if (el.tagName === 'SPAN' &&
+                    el.getAttribute('data-type') === 'mention' &&
+                    el.hasAttribute('data-id')) {
+                    //Create mention to ultimately insert into the DOM
+                    const span = document.createElement('span');
+                    span.className = this.readonly ? 'readonly-mention' : 'mention';
+                    span.setAttribute('data-id', el.getAttribute('data-id') || '');
+                    span.setAttribute('data-type', 'mention');
+                    span.setAttribute('contenteditable', 'false');
+                    const raw = el.textContent || '';
+                    span.textContent = raw.startsWith('@') ? raw : `@${raw}`;
+                    nodes.push(span);
+                }
+                else if (el.tagName === 'BR') {
+                    // Preserve line breaks
+                    nodes.push(document.createElement('br'));
+                }
+                else {
+                    //Recursively look for nested children
+                    for (const child of Array.from(el.childNodes)) {
+                        walk(child);
+                    }
+                }
+            }
+            else if (node.nodeType === Node.TEXT_NODE) {
+                const text = (node.textContent || '').replace(ZWS_REGEX, '');
+                if (text) {
+                    nodes.push(document.createTextNode(text));
+                }
+            }
+        };
+        for (const child of Array.from(tempContainer.childNodes)) {
+            walk(child);
+        }
+        //DAHNE NOTE - the result here should be an array of text/span-mention/br nodes
+        return nodes;
+    }
+    insertNodesAtCursor(nodes) {
+        //Get selection object, representing user cursor position/selection
+        //Get Range object at start of selection, which should represent cursor position
+        //If there is a selection, delete it
+        //Insert the parsed nodes from above, move range ends to after node
+        //Then remove the range and reset it to move the cursor position to the end
+        const selection = window.getSelection();
+        if (!selection?.rangeCount) {
+            return;
+        }
+        const range = selection.getRangeAt(0);
+        range.deleteContents();
+        let cursorTarget = null;
+        for (const node of nodes) {
+            if (MentionsInputComponent.isMention(node)) {
+                const before = document.createTextNode(ZWS);
+                const after = document.createTextNode(ZWS);
+                range.insertNode(before);
+                range.setStartAfter(before);
+                range.insertNode(node);
+                range.setStartAfter(node);
+                range.insertNode(after);
+                range.setStartAfter(after);
+                cursorTarget = after;
+            }
+            else {
+                range.insertNode(node);
+                range.setStartAfter(node);
+                cursorTarget = node;
+            }
+            range.collapse(true);
+        }
+        // After a mention, leave the cursor inside the trailing ZWS so ArrowLeft
+        // can step back to before-the-mention naturally.
+        if (cursorTarget && MentionsInputComponent.isZws(cursorTarget)) {
+            range.setStart(cursorTarget, 0);
+            range.collapse(true);
+        }
+        selection.removeAllRanges();
+        selection.addRange(range);
+    }
+    insertLineBreak() {
+        const selection = window.getSelection();
+        if (!selection?.rangeCount || !this.inputElement?.nativeElement) {
+            return;
+        }
+        const range = selection.getRangeAt(0);
+        range.deleteContents();
+        const br = document.createElement('br');
+        range.insertNode(br);
+        range.setStartAfter(br);
+        range.collapse(true);
+        // A trailing <br> alone doesn't render an empty line in contenteditable —
+        // a ZWS gives the caret a place to land.
+        if (!br.nextSibling) {
+            const zws = document.createTextNode(ZWS);
+            range.insertNode(zws);
+            range.setStart(zws, 0);
+            range.collapse(true);
+        }
+        selection.removeAllRanges();
+        selection.addRange(range);
+    }
+    // ─── Mention trigger / dropdown ────────────────────────────────────────
+    checkForMentionTrigger() {
+        const selection = window.getSelection();
+        if (!selection || !selection.rangeCount || !this.inputElement) {
+            return;
+        }
+        const range = selection.getRangeAt(0);
+        const textBeforeCursor = this.getTextBeforeCursor(range);
+        const lastAtIndex = textBeforeCursor.lastIndexOf('@');
+        if (lastAtIndex === -1) {
+            this.closeMentions();
+            return;
+        }
+        //If we allow for a single space, we need to check to make sure that this logic won't pick up previous
+        //'@' mentions and keep the mention dropdown open
+        const atPosition = this.findDomPositionAtCharIndex(lastAtIndex);
+        if (atPosition && this.isInsideMentionSpan(atPosition.node)) {
+            this.closeMentions();
+            return;
+        }
+        const textAfterAt = textBeforeCursor.substring(lastAtIndex + 1);
+        const char1 = textAfterAt.charCodeAt(0);
+        const charN = textAfterAt.charCodeAt(textAfterAt.length - 1);
+        const charN_1 = textAfterAt.charCodeAt(textAfterAt.length - 2);
+        //These are the Unicode representations of normal space and non-breaking space
+        const unicodeSpaceChars = [32, 160];
+        // Close mentions if:
+        // - There's a double space (allows single spaces in the middle of search)
+        // - The text starts with a space (typing "@ " should not trigger mentions)
+        if (textAfterAt.includes('  ') ||
+            textAfterAt.startsWith(' ') ||
+            char1 == 160 ||
+            (unicodeSpaceChars.includes(charN) && unicodeSpaceChars.includes(charN_1))) {
+            this.closeMentions();
+            return;
+        }
+        // Trim trailing/leading spaces from search text while preserving spaces in the middle
+        this.mentionSearchText = textAfterAt.trim();
+        // Only show mentions if there are filtered users
+        const filteredUsers = this.getFilteredUsers();
+        if (filteredUsers.length === 0) {
+            this.closeMentions();
+            return;
+        }
+        this.mentionsVisible = true;
+        this.selectedUserIndex = 0;
+        //Save the current range for later restoration (needed for click selection)
+        //DAHNE NOTE - this is annoyingly neceessary because clicks and enter keys have different effects on the
+        //focus of the contenteditable div
+        this.savedRange = range.cloneRange();
+        if (atPosition) {
+            const atRange = document.createRange();
+            atRange.setStart(atPosition.node, atPosition.offset);
+            atRange.setEnd(atPosition.node, atPosition.offset + 1);
+            this.mentionAnchor = atRange.getBoundingClientRect();
+        }
+        this.cdr.markForCheck();
+    }
+    getTextBeforeCursor(range) {
+        const clonedRange = range.cloneRange();
+        //We select all of the input contents, and then move the end point to the current cursor position
+        clonedRange.selectNodeContents(this.inputElement.nativeElement);
+        clonedRange.setEnd(range.endContainer, range.endOffset);
+        //Create a temporary div so that we can extract text content from it
+        const fragment = clonedRange.cloneContents();
+        const div = document.createElement('div');
+        div.appendChild(fragment);
+        //Get text content, replacing mention spans with @name
+        return div.textContent || '';
+    }
+    getFilteredUsers() {
+        const users = !this.mentionSearchText
+            ? this.users
+            : this.users.filter(user => user.name
+                .toLowerCase()
+                .includes(this.mentionSearchText.toLowerCase()));
+        return users.slice().sort((a, b) => a.name.localeCompare(b.name));
+    }
+    onUserHover(index) {
+        this.selectedUserIndex = index;
+        this.cdr.markForCheck();
+    }
+    selectUser(user) {
+        if (!this.inputElement) {
+            return;
+        }
+        //This gets DOM info from user (e.g. highlighted selections, and cursor position)
+        const selection = window.getSelection();
+        if (!selection) {
+            return;
+        }
+        // Restore the saved range if available (needed when selecting via click)
+        if (this.savedRange) {
+            selection.removeAllRanges();
+            selection.addRange(this.savedRange);
+        }
+        if (!selection.rangeCount) {
+            return;
+        }
+        // Delete the "@" and search text
+        this.deleteAtMentionSearch();
+        //DAHNE NOTE - this would ideally be the same as contentItemToHTML, but we need an actual element reference here in order to append it to the DOM
+        const mentionSpan = document.createElement('span');
+        mentionSpan.className = this.readonly ? 'readonly-mention' : 'mention';
+        mentionSpan.setAttribute('data-id', String(user.id));
+        mentionSpan.setAttribute('data-type', 'mention');
+        mentionSpan.setAttribute('contenteditable', 'false');
+        mentionSpan.textContent = `@${user.name}`;
+        this.insertNodesAtCursor([mentionSpan, document.createTextNode(' ')]);
+        this.normalizeMentionPadding();
+        this.closeMentions();
+        this.emitContentChange();
+    }
+    deleteAtMentionSearch() {
+        const selection = window.getSelection();
+        if (!selection || !selection.rangeCount) {
+            return;
+        }
+        //This represents the current position of the cursor
+        const cursorRange = selection.getRangeAt(0);
+        //This will return all of the raw text (HTML-stripped) before the cursor
+        const textBeforeCursor = this.getTextBeforeCursor(cursorRange);
+        //We do that^ so that we can find the correct index of the most recent '@'
+        const lastAtIndex = textBeforeCursor.lastIndexOf('@');
+        if (lastAtIndex === -1) {
+            return;
+        }
+        const atPosition = this.findDomPositionAtCharIndex(lastAtIndex);
+        if (!atPosition) {
+            return;
+        }
+        // Create range from "@" to cursor and delete it
+        const deleteRange = document.createRange();
+        deleteRange.setStart(atPosition.node, atPosition.offset);
+        deleteRange.setEnd(cursorRange.endContainer, cursorRange.endOffset);
+        deleteRange.deleteContents();
+    }
+    isInsideMentionSpan(node) {
+        let currentNode = node;
+        while (currentNode && currentNode !== this.inputElement?.nativeElement) {
+            if (MentionsInputComponent.isMention(currentNode)) {
+                return true;
+            }
+            currentNode = currentNode.parentNode;
+        }
+        return false;
+    }
+    //This will go text node by node looking for the
+    //@ mention and give its position in the context of that node
+    findDomPositionAtCharIndex(charIndex) {
+        if (!this.inputElement) {
+            return null;
+        }
+        // Walk through all text nodes in the input, counting characters
+        const treeWalker = document.createTreeWalker(this.inputElement.nativeElement, NodeFilter.SHOW_TEXT, null);
+        let charCount = 0;
+        while (treeWalker.nextNode()) {
+            const node = treeWalker.currentNode;
+            const text = node.textContent || '';
+            // Check if our target character is in this text node
+            if (charCount + text.length > charIndex) {
+                return { node, offset: charIndex - charCount };
+            }
+            charCount += text.length;
+        }
+        return null;
+    }
+    closeMentions() {
+        this.mentionsVisible = false;
+        this.mentionSearchText = '';
+        this.mentionAnchor = null;
+        this.selectedUserIndex = 0;
+        this.savedRange = null;
+        this.cdr.markForCheck();
+    }
+    emitContentChange() {
+        if (!this.inputElement) {
+            return;
+        }
+        this.contentChange.emit(this.domToContentItems());
+    }
+    domToContentItems() {
+        if (!this.inputElement?.nativeElement) {
+            return [];
+        }
+        const items = [];
+        const childNodes = this.inputElement.nativeElement.childNodes;
+        for (const node of Array.from(childNodes)) {
+            if (node.nodeType === Node.ELEMENT_NODE) {
+                const element = node;
+                if (element.tagName === 'SPAN' &&
+                    element.getAttribute('data-type') === 'mention') {
+                    const id = Number(element.getAttribute('data-id'));
+                    const name = element.textContent?.replace('@', '') || '';
+                    items.push({ type: 'mention', id, name });
+                }
+                else if (element.tagName === 'BR') {
+                    items.push({ type: 'newline' });
+                }
+            }
+            else if (node.nodeType === Node.TEXT_NODE) {
+                // ZWS pads are a DOM affordance — they shouldn't leak into the data model.
+                const text = (node.textContent || '').replace(ZWS_REGEX, '');
+                if (text) {
+                    items.push({ type: 'text', text });
+                }
+            }
+        }
+        return items;
+    }
+    onCalloutClose() {
+        this.closeMentions();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MentionsInputComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MentionsInputComponent, selector: "riv-mentions-input", inputs: { content: "content", users: "users", readonly: "readonly", placeholder: "placeholder" }, outputs: { contentChange: "contentChange" }, viewQueries: [{ propertyName: "inputElement", first: true, predicate: ["input"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"mentions-container\" #container>\n  <div\n    *ngIf=\"!readonly\"\n    #input\n    class=\"text-content editable\"\n    contenteditable=\"true\"\n    [attr.data-placeholder]=\"placeholder\"\n    (input)=\"onInput()\"\n    (keydown)=\"onKeyDown($event)\"\n    (paste)=\"onPaste($event)\"\n    (copy)=\"onCopy($event)\"\n    (cut)=\"onCut($event)\"\n  ></div>\n\n  <div *ngIf=\"readonly\" #input class=\"text-content\"></div>\n\n  <riv-callout\n    *ngIf=\"!readonly && mentionsVisible && mentionAnchor\"\n    [anchor]=\"mentionAnchor\"\n    [isModal]=\"true\"\n    [showCaret]=\"false\"\n    [allowedPositions]=\"['bottom-right', 'top-right']\"\n    [theme]=\"'light'\"\n    (close)=\"onCalloutClose()\"\n  >\n    <div class=\"mentions-content\">\n      <div class=\"mentions-header\">Mention someone</div>\n      <div class=\"mentions-list\">\n        <button\n          type=\"button\"\n          *ngFor=\"let user of getFilteredUsers(); let i = index\"\n          [class.selected]=\"i === selectedUserIndex\"\n          (mouseenter)=\"onUserHover(i)\"\n          (click)=\"selectUser(user)\"\n        >\n          {{ user.name }}\n        </button>\n      </div>\n    </div>\n  </riv-callout>\n</div>\n", styles: [".mentions-container{position:relative;width:100%}.mentions-input{width:100%;border:var(--border-width) solid var(--border-light);border-radius:var(--border-radius-small);color:var(--type-light-high-contrast);overflow-y:auto;white-space:pre-wrap;word-wrap:break-word}.mentions-input:empty:before{content:attr(data-placeholder);color:var(--type-light-low-contrast);pointer-events:none}.mentions-input:focus{outline:none;border:var(--border-width) solid var(--purp-60)}.mentions-input[contenteditable=false]{color:var(--type-light-disabled);background-color:var(--surface-light-1);cursor:not-allowed}span.mention{color:var(--type-light-link);font-weight:var(--font-weight-heavy);white-space:nowrap;display:inline}span.readonly-mention{font-weight:var(--font-weight-heavy);white-space:nowrap;display:inline}.mentions-input.warning{border-color:var(--surface-dark-caution)}.mentions-input.error{border-color:var(--surface-dark-danger);box-shadow:inset 0 0 0 var(--border-width-large) var(--surface-dark-danger)}.mentions-input.large{font:var(--input-large);padding:var(--size-medium)}.mentions-list{margin:0;padding:0;max-height:calc(var(--base-grid-size) * 50);overflow-y:auto;display:flex;flex-direction:column;gap:var(--size-xxsmall)}.mentions-list button{padding:var(--size-small) var(--size-small);border-radius:var(--border-radius-medium);cursor:pointer;transition:background-color .2s;font:var(--input-medium);text-align:left}.mentions-list button:hover,.mentions-list button.selected{background-color:var(--surface-light-2)}.mentions-content{max-height:50vh;min-width:calc(var(--base-grid-size) * 62);max-width:50vw;padding:var(--size-large);display:flex;flex-direction:column}.mentions-header{padding:var(--size-small) var(--size-small);font:var(--input-medium);color:var(--type-light-low-contrast)}.text-content{width:100%;min-height:9em;border-radius:var(--border-radius-small);font:var(--input-medium);color:var(--type-light-high-contrast);padding:var(--size-large);resize:vertical}.editable{border:var(--border-width) solid var(--border-light);background-color:var(--surface-light-0)}.text-content::placeholder{color:var(--type-light-low-contrast)}.text-content.editable[data-placeholder]:empty:before{content:attr(data-placeholder);color:var(--type-light-low-contrast)}.text-content:disabled{color:var(--type-light-disabled);background-color:var(--surface-light-1)}.text-content:focus{outline:none;border:var(--border-width) solid var(--purp-60)}.text-content.warning{border-color:var(--surface-dark-caution)}.text-content.error{border-color:var(--surface-dark-danger);box-shadow:inset 0 0 0 var(--border-width-large) var(--surface-dark-danger)}.text-content.large{font:var(--input-large);padding:var(--size-medium)}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.CalloutComponent, selector: "riv-callout", inputs: ["anchor", "isModal", "preferredPosition", "allowedPositions", "fallbackDirection", "showCaret", "theme"], outputs: ["close"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MentionsInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'riv-mentions-input', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"mentions-container\" #container>\n  <div\n    *ngIf=\"!readonly\"\n    #input\n    class=\"text-content editable\"\n    contenteditable=\"true\"\n    [attr.data-placeholder]=\"placeholder\"\n    (input)=\"onInput()\"\n    (keydown)=\"onKeyDown($event)\"\n    (paste)=\"onPaste($event)\"\n    (copy)=\"onCopy($event)\"\n    (cut)=\"onCut($event)\"\n  ></div>\n\n  <div *ngIf=\"readonly\" #input class=\"text-content\"></div>\n\n  <riv-callout\n    *ngIf=\"!readonly && mentionsVisible && mentionAnchor\"\n    [anchor]=\"mentionAnchor\"\n    [isModal]=\"true\"\n    [showCaret]=\"false\"\n    [allowedPositions]=\"['bottom-right', 'top-right']\"\n    [theme]=\"'light'\"\n    (close)=\"onCalloutClose()\"\n  >\n    <div class=\"mentions-content\">\n      <div class=\"mentions-header\">Mention someone</div>\n      <div class=\"mentions-list\">\n        <button\n          type=\"button\"\n          *ngFor=\"let user of getFilteredUsers(); let i = index\"\n          [class.selected]=\"i === selectedUserIndex\"\n          (mouseenter)=\"onUserHover(i)\"\n          (click)=\"selectUser(user)\"\n        >\n          {{ user.name }}\n        </button>\n      </div>\n    </div>\n  </riv-callout>\n</div>\n", styles: [".mentions-container{position:relative;width:100%}.mentions-input{width:100%;border:var(--border-width) solid var(--border-light);border-radius:var(--border-radius-small);color:var(--type-light-high-contrast);overflow-y:auto;white-space:pre-wrap;word-wrap:break-word}.mentions-input:empty:before{content:attr(data-placeholder);color:var(--type-light-low-contrast);pointer-events:none}.mentions-input:focus{outline:none;border:var(--border-width) solid var(--purp-60)}.mentions-input[contenteditable=false]{color:var(--type-light-disabled);background-color:var(--surface-light-1);cursor:not-allowed}span.mention{color:var(--type-light-link);font-weight:var(--font-weight-heavy);white-space:nowrap;display:inline}span.readonly-mention{font-weight:var(--font-weight-heavy);white-space:nowrap;display:inline}.mentions-input.warning{border-color:var(--surface-dark-caution)}.mentions-input.error{border-color:var(--surface-dark-danger);box-shadow:inset 0 0 0 var(--border-width-large) var(--surface-dark-danger)}.mentions-input.large{font:var(--input-large);padding:var(--size-medium)}.mentions-list{margin:0;padding:0;max-height:calc(var(--base-grid-size) * 50);overflow-y:auto;display:flex;flex-direction:column;gap:var(--size-xxsmall)}.mentions-list button{padding:var(--size-small) var(--size-small);border-radius:var(--border-radius-medium);cursor:pointer;transition:background-color .2s;font:var(--input-medium);text-align:left}.mentions-list button:hover,.mentions-list button.selected{background-color:var(--surface-light-2)}.mentions-content{max-height:50vh;min-width:calc(var(--base-grid-size) * 62);max-width:50vw;padding:var(--size-large);display:flex;flex-direction:column}.mentions-header{padding:var(--size-small) var(--size-small);font:var(--input-medium);color:var(--type-light-low-contrast)}.text-content{width:100%;min-height:9em;border-radius:var(--border-radius-small);font:var(--input-medium);color:var(--type-light-high-contrast);padding:var(--size-large);resize:vertical}.editable{border:var(--border-width) solid var(--border-light);background-color:var(--surface-light-0)}.text-content::placeholder{color:var(--type-light-low-contrast)}.text-content.editable[data-placeholder]:empty:before{content:attr(data-placeholder);color:var(--type-light-low-contrast)}.text-content:disabled{color:var(--type-light-disabled);background-color:var(--surface-light-1)}.text-content:focus{outline:none;border:var(--border-width) solid var(--purp-60)}.text-content.warning{border-color:var(--surface-dark-caution)}.text-content.error{border-color:var(--surface-dark-danger);box-shadow:inset 0 0 0 var(--border-width-large) var(--surface-dark-danger)}.text-content.large{font:var(--input-large);padding:var(--size-medium)}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { content: [{
+                type: Input
+            }], users: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], contentChange: [{
+                type: Output
+            }], inputElement: [{
+                type: ViewChild,
+                args: ['input', { static: false }]
+            }] } });
+(function (MentionsInputComponent) {
+    MentionsInputComponent.ContentTypes = ['mention', 'text', 'newline'];
+    function contentToPlainText(content) {
+        return content
+            .map(item => {
+            switch (item.type) {
+                case 'mention':
+                    return `@${item.name}`;
+                case 'text':
+                    return item.text;
+                case 'newline':
+                    return '\n';
+            }
+        })
+            .join('');
+    }
+    MentionsInputComponent.contentToPlainText = contentToPlainText;
+})(MentionsInputComponent || (MentionsInputComponent = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mentions-input.component.js","sourceRoot":"","sources":["../../../../../../projects/riv/src/lib/input/mentions-input/mentions-input.component.ts","../../../../../../projects/riv/src/lib/input/mentions-input/mentions-input.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  Output,\n  SimpleChanges,\n  ViewChild,\n  ViewEncapsulation,\n} from '@angular/core';\n\nconst ZWS = '​';\nconst ZWS_REGEX = /​/g;\n\n/**\n * A rich text input that supports `@`-mentions inside a `contenteditable` div.\n *\n * ## Data Model\n * - **Input/Output**: `ContentItem[]` (mentions, text, newlines)\n *\n * ## DOM Invariant\n * Every mention `<span data-type=\"mention\" contenteditable=\"false\">` is wrapped\n * by exactly one zero-width-space (ZWS) text node before and after it. ZWS gives\n * the cursor a valid landing spot adjacent to a non-editable element. The\n * invariant is established at render time and re-established by\n * `normalizeMentionPadding()` after any DOM-mutating operation.\n *\n * ## Copy/Paste\n * - **Copy**: `range.cloneContents()` preserves `data-*` attributes (only the\n *   browser's default copy path strips them). We override copy, serialize the\n *   clone ourselves, and strip ZWS from the output.\n * - **Paste**: HTML paths look for `data-type=\"mention\"` spans and rebuild\n *   them; otherwise plaintext fallback.\n */\n@Component({\n  selector: 'riv-mentions-input',\n  templateUrl: `./mentions-input.component.html`,\n  styleUrls: ['./mentions-input.component.css'],\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MentionsInputComponent implements OnChanges, AfterViewInit {\n  constructor(private readonly cdr: ChangeDetectorRef) {}\n\n  @Input() content: MentionsInputComponent.ContentItem[] = [];\n  @Input() users: MentionsInputComponent.User[] = [];\n  @Input() readonly = false;\n  @Input() placeholder: string = 'Add a comment';\n\n  @Output() readonly contentChange = new EventEmitter<\n    MentionsInputComponent.ContentItem[]\n  >();\n\n  @ViewChild('input', { static: false })\n  private readonly inputElement?: ElementRef<HTMLDivElement>;\n\n  mentionsVisible = false;\n  mentionSearchText = '';\n  mentionAnchor: DOMRect | null = null;\n  selectedUserIndex = 0;\n  private savedRange: Range | null = null;\n\n  ngAfterViewInit(): void {\n    this.renderContent();\n  }\n\n  //DAHNE NOTE - ngOnChanges is called whenever any @Input() property changes, where the changed input contains information about those changes\n  //So if @Input() content changes and it's not the first change (the first render is handled by ngAfterViewInit()), we render the content\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['content'] && !changes['content'].firstChange) {\n      this.renderContent();\n    }\n  }\n\n  private renderContent(): void {\n    //This is necessary because the @ViewChild reference isn't available until after the view initializes\n    if (!this.inputElement?.nativeElement) {\n      return;\n    }\n    const html = this.content\n      .map(item => {\n        const itemHtml = MentionsInputComponent.contentItemToHtml(\n          item,\n          this.readonly,\n        );\n        return item.type === 'mention' ? `${ZWS}${itemHtml}${ZWS}` : itemHtml;\n      })\n      .join('');\n    this.inputElement.nativeElement.innerHTML = html;\n  }\n\n  private static contentItemToHtml(\n    item: MentionsInputComponent.ContentItem,\n    readonly: boolean,\n  ): string {\n    switch (item.type) {\n      //DAHNE TODO - maybe we escape HTML here too? Although I don't think it will be possible for users to input an XSS attack in item.name\n      case 'mention':\n        return `<span class=\"${\n          readonly ? 'readonly-mention' : 'mention'\n        }\" data-id=\"${\n          item.id\n        }\" data-type=\"mention\" contenteditable=\"false\">@${MentionsInputComponent.escapeHtml(\n          item.name,\n        )}</span>`;\n      case 'text':\n        return MentionsInputComponent.escapeHtml(item.text);\n      case 'newline':\n        return '<br>';\n    }\n  }\n\n  private static escapeHtml(text: string): string {\n    const div = document.createElement('div');\n    div.textContent = text;\n    return div.innerHTML;\n  }\n\n  // ─── Event handlers ───────────────────────────────────────────────────\n\n  onInput(): void {\n    this.normalizeMentionPadding();\n    this.checkForMentionTrigger();\n    this.emitContentChange();\n  }\n\n  onKeyDown(event: KeyboardEvent): void {\n    if (this.mentionsVisible) {\n      this.handleMentionsDropdownNav(event);\n      return;\n    }\n\n    // Word/line jump: native behavior.\n    if (event.metaKey || event.ctrlKey) {\n      return;\n    }\n\n    if (event.key === 'ArrowLeft' || event.key === 'ArrowRight') {\n      const direction = event.key === 'ArrowLeft' ? 'before' : 'after';\n      const mention = this.findMentionAdjacentToCursor(direction);\n      if (mention) {\n        event.preventDefault();\n        if (event.shiftKey) {\n          this.extendSelectionAcrossMention(mention, direction);\n        } else {\n          this.placeCursorAdjacentToMention(mention, direction);\n        }\n      }\n      return;\n    }\n\n    if (event.key === 'Backspace' || event.key === 'Delete') {\n      const direction = event.key === 'Backspace' ? 'before' : 'after';\n      const mention = this.findMentionAdjacentToCursor(direction);\n      if (mention) {\n        event.preventDefault();\n        this.removeMention(mention);\n        this.emitContentChange();\n        return;\n      }\n      if (event.key === 'Backspace') {\n        const br = this.findBrAdjacentToCursor();\n        if (br) {\n          event.preventDefault();\n          br.remove();\n          this.emitContentChange();\n        }\n      }\n      return;\n    }\n    //Handle newlines when mentions aren't visible\n    if (event.key === 'Enter') {\n      event.preventDefault();\n      this.insertLineBreak();\n      this.emitContentChange();\n    }\n  }\n\n  onPaste(event: ClipboardEvent): void {\n    event.preventDefault();\n    if (!event.clipboardData) {\n      return;\n    }\n    //Look for HTML first\n    const html = event.clipboardData.getData('text/html');\n    const plainText = event.clipboardData.getData('text/plain');\n\n    const nodes =\n      html && html.includes('data-type=\"mention\"')\n        ? this.parsePastedHtml(html)\n        : this.plainTextToNodes(plainText);\n\n    this.insertNodesAtCursor(nodes);\n    this.normalizeMentionPadding();\n    this.emitContentChange();\n  }\n\n  // The browser strips data-* attributes during default copy serialization, but\n  // range.cloneContents() preserves them. We serialize the clone ourselves and\n  // strip ZWS so it doesn't leak into the clipboard.\n  onCopy(event: ClipboardEvent): void {\n    const selection = window.getSelection();\n    if (!selection?.rangeCount) {\n      return;\n    }\n    event.preventDefault();\n\n    const div = document.createElement('div');\n    div.appendChild(selection.getRangeAt(0).cloneContents());\n\n    const html = div.innerHTML.replace(ZWS_REGEX, '');\n    const text = (div.textContent || '').replace(ZWS_REGEX, '');\n\n    event.clipboardData?.setData('text/html', html);\n    event.clipboardData?.setData('text/plain', text);\n  }\n\n  onCut(event: ClipboardEvent): void {\n    this.onCopy(event);\n    const selection = window.getSelection();\n    if (!selection?.rangeCount) {\n      return;\n    }\n    selection.getRangeAt(0).deleteContents();\n    this.normalizeMentionPadding();\n    this.emitContentChange();\n  }\n\n  // ─── Mention helpers ───────────────────────────────────────────────────\n\n  private static isMention(node: Node | null | undefined): node is HTMLElement {\n    return (\n      !!node &&\n      node.nodeType === Node.ELEMENT_NODE &&\n      (node as HTMLElement).getAttribute('data-type') === 'mention'\n    );\n  }\n\n  private static isZws(node: Node | null | undefined): boolean {\n    return (\n      !!node &&\n      node.nodeType === Node.TEXT_NODE &&\n      (node.textContent || '').replace(ZWS_REGEX, '') === ''\n    );\n  }\n\n  // Resolve the node logically adjacent to (container, offset) in the given\n  // direction, transparently skipping any ZWS-only text nodes in between.\n  private resolveAdjacentNode(\n    container: Node,\n    offset: number,\n    direction: 'before' | 'after',\n  ): Node | null {\n    let candidate: Node | null = null;\n\n    if (container.nodeType === Node.TEXT_NODE) {\n      const length = (container.textContent || '').length;\n      const atBoundary =\n        MentionsInputComponent.isZws(container) ||\n        (direction === 'before' ? offset === 0 : offset === length);\n      if (!atBoundary) {\n        return null;\n      }\n      candidate =\n        direction === 'before'\n          ? container.previousSibling\n          : container.nextSibling;\n    } else if (container.nodeType === Node.ELEMENT_NODE) {\n      const children = (container as HTMLElement).childNodes;\n      candidate =\n        direction === 'before' ? children[offset - 1] : children[offset];\n    }\n\n    while (candidate && MentionsInputComponent.isZws(candidate)) {\n      candidate =\n        direction === 'before'\n          ? candidate.previousSibling\n          : candidate.nextSibling;\n    }\n    return candidate;\n  }\n\n  private findMentionAdjacentToCursor(\n    direction: 'before' | 'after',\n  ): HTMLElement | null {\n    const selection = window.getSelection();\n    if (!selection?.isCollapsed || !selection.rangeCount) {\n      return null;\n    }\n    const range = selection.getRangeAt(0);\n    const node = this.resolveAdjacentNode(\n      range.startContainer,\n      range.startOffset,\n      direction,\n    );\n    return MentionsInputComponent.isMention(node) ? node : null;\n  }\n\n  private findBrAdjacentToCursor(): HTMLElement | null {\n    const selection = window.getSelection();\n    if (!selection?.isCollapsed || !selection.rangeCount) {\n      return null;\n    }\n    const range = selection.getRangeAt(0);\n    const node = this.resolveAdjacentNode(\n      range.startContainer,\n      range.startOffset,\n      'before',\n    );\n    return node?.nodeName === 'BR' ? (node as HTMLElement) : null;\n  }\n\n  private extendSelectionAcrossMention(\n    mention: HTMLElement,\n    direction: 'before' | 'after',\n  ): void {\n    const selection = window.getSelection();\n    const parent = mention.parentNode;\n    if (!selection || !parent) {\n      return;\n    }\n    const index = Array.from(parent.childNodes).indexOf(mention as ChildNode);\n    selection.extend(parent, direction === 'before' ? index : index + 1);\n  }\n\n  private placeCursorAdjacentToMention(\n    mention: HTMLElement,\n    side: 'before' | 'after',\n  ): void {\n    const parent = mention.parentNode;\n    if (!parent) {\n      return;\n    }\n    const sibling =\n      side === 'before' ? mention.previousSibling : mention.nextSibling;\n    let zws: Node;\n    if (sibling && MentionsInputComponent.isZws(sibling)) {\n      zws = sibling;\n    } else {\n      zws = document.createTextNode(ZWS);\n      parent.insertBefore(\n        zws,\n        side === 'before' ? mention : mention.nextSibling,\n      );\n    }\n    const range = document.createRange();\n    range.setStart(zws, side === 'before' ? (zws.textContent || '').length : 0);\n    range.collapse(true);\n    const selection = window.getSelection();\n    selection?.removeAllRanges();\n    selection?.addRange(range);\n  }\n\n  private removeMention(mention: HTMLElement): void {\n    const parent = mention.parentNode;\n    if (!parent) {\n      return;\n    }\n    // Empty text-node anchor preserves cursor position through the removal.\n    const anchor = document.createTextNode('');\n    parent.insertBefore(anchor, mention);\n\n    const prev = mention.previousSibling;\n    const next = mention.nextSibling;\n    if (prev && MentionsInputComponent.isZws(prev)) {\n      prev.remove();\n    }\n    if (next && MentionsInputComponent.isZws(next)) {\n      next.remove();\n    }\n    mention.remove();\n\n    const range = document.createRange();\n    range.setStart(anchor, 0);\n    range.collapse(true);\n    const selection = window.getSelection();\n    selection?.removeAllRanges();\n    selection?.addRange(range);\n  }\n\n  // Re-establishes the invariant: every mention has exactly one ZWS text\n  // node immediately before and after it, and there are no orphan ZWS-only\n  // text nodes anywhere else. Run after any operation that may disturb the\n  // tree (typing, paste, cut, delete) so cruft doesn't accumulate across\n  // repeated copy/paste cycles.\n  private normalizeMentionPadding(): void {\n    const root = this.inputElement?.nativeElement;\n    if (!root) {\n      return;\n    }\n\n    // 1. Ensure each mention has a ZWS pad on both sides.\n    const mentions = Array.from(\n      root.querySelectorAll('span[data-type=\"mention\"]'),\n    ) as HTMLElement[];\n    for (const m of mentions) {\n      const parent = m.parentNode;\n      if (!parent) {\n        continue;\n      }\n      if (\n        !m.previousSibling ||\n        !MentionsInputComponent.isZws(m.previousSibling)\n      ) {\n        parent.insertBefore(document.createTextNode(ZWS), m);\n      }\n      if (!m.nextSibling || !MentionsInputComponent.isZws(m.nextSibling)) {\n        parent.insertBefore(document.createTextNode(ZWS), m.nextSibling);\n      }\n    }\n\n    // 2. Remove any ZWS-only text node that isn't directly adjacent to a\n    //    mention (orphans from line-break pads, leftover splits from previous\n    //    paste insertions, duplicate pads from accumulated copy/paste cycles).\n    //    Skip a node if the cursor currently lives in it — preserves caret\n    //    position without needing manual restoration.\n    const selection = window.getSelection();\n    const cursorNode =\n      selection?.rangeCount &&\n      root.contains(selection.getRangeAt(0).startContainer)\n        ? selection.getRangeAt(0).startContainer\n        : null;\n\n    const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, null);\n    const orphans: Text[] = [];\n    while (walker.nextNode()) {\n      const node = walker.currentNode as Text;\n      if (!MentionsInputComponent.isZws(node) || node === cursorNode) {\n        continue;\n      }\n      const adjacentToMention =\n        MentionsInputComponent.isMention(node.previousSibling) ||\n        MentionsInputComponent.isMention(node.nextSibling);\n      if (!adjacentToMention) {\n        orphans.push(node);\n      }\n    }\n    for (const node of orphans) {\n      node.remove();\n    }\n  }\n\n  private handleMentionsDropdownNav(event: KeyboardEvent): void {\n    const filteredUsers = this.getFilteredUsers();\n    if (filteredUsers.length === 0) {\n      this.closeMentions();\n      return;\n    }\n\n    switch (event.key) {\n      case 'ArrowDown':\n        event.preventDefault();\n        this.selectedUserIndex = Math.min(\n          this.selectedUserIndex + 1,\n          filteredUsers.length - 1,\n        );\n        this.cdr.markForCheck();\n        break;\n      case 'ArrowUp':\n        event.preventDefault();\n        this.selectedUserIndex = Math.max(this.selectedUserIndex - 1, 0);\n        this.cdr.markForCheck();\n        break;\n      case 'Enter':\n      case 'Tab':\n        event.preventDefault();\n        if (filteredUsers[this.selectedUserIndex]) {\n          this.selectUser(filteredUsers[this.selectedUserIndex]);\n        }\n        break;\n      case 'Escape':\n        event.preventDefault();\n        this.closeMentions();\n        break;\n    }\n  }\n\n  // ─── Insertion ─────────────────────────────────────────────────────────\n\n  private plainTextToNodes(text: string): Node[] {\n    const nodes: Node[] = [];\n    const lines = text.split('\\n');\n    lines.forEach((line, index) => {\n      if (line) {\n        nodes.push(document.createTextNode(line));\n      }\n      if (index < lines.length - 1) {\n        nodes.push(document.createElement('br'));\n      }\n    });\n    return nodes;\n  }\n  // Create a temporary container to parse the HTML\n  private parsePastedHtml(html: string): Node[] {\n    // Create a temporary container to parse the HTML\n    const tempContainer = document.createElement('div');\n    tempContainer.innerHTML = html;\n\n    const nodes: Node[] = [];\n    const walk = (node: Node): void => {\n      if (node.nodeType === Node.ELEMENT_NODE) {\n        const el = node as HTMLElement;\n        // DAHNE NOTE - we only want mention spans, br elements, and text\n        if (\n          el.tagName === 'SPAN' &&\n          el.getAttribute('data-type') === 'mention' &&\n          el.hasAttribute('data-id')\n        ) {\n          //Create mention to ultimately insert into the DOM\n          const span = document.createElement('span');\n          span.className = this.readonly ? 'readonly-mention' : 'mention';\n          span.setAttribute('data-id', el.getAttribute('data-id') || '');\n          span.setAttribute('data-type', 'mention');\n          span.setAttribute('contenteditable', 'false');\n          const raw = el.textContent || '';\n          span.textContent = raw.startsWith('@') ? raw : `@${raw}`;\n          nodes.push(span);\n        } else if (el.tagName === 'BR') {\n          // Preserve line breaks\n          nodes.push(document.createElement('br'));\n        } else {\n          //Recursively look for nested children\n          for (const child of Array.from(el.childNodes)) {\n            walk(child);\n          }\n        }\n      } else if (node.nodeType === Node.TEXT_NODE) {\n        const text = (node.textContent || '').replace(ZWS_REGEX, '');\n        if (text) {\n          nodes.push(document.createTextNode(text));\n        }\n      }\n    };\n\n    for (const child of Array.from(tempContainer.childNodes)) {\n      walk(child);\n    }\n    //DAHNE NOTE - the result here should be an array of text/span-mention/br nodes\n    return nodes;\n  }\n\n  private insertNodesAtCursor(nodes: Node[]): void {\n    //Get selection object, representing user cursor position/selection\n    //Get Range object at start of selection, which should represent cursor position\n    //If there is a selection, delete it\n    //Insert the parsed nodes from above, move range ends to after node\n    //Then remove the range and reset it to move the cursor position to the end\n    const selection = window.getSelection();\n    if (!selection?.rangeCount) {\n      return;\n    }\n    const range = selection.getRangeAt(0);\n    range.deleteContents();\n\n    let cursorTarget: Node | null = null;\n    for (const node of nodes) {\n      if (MentionsInputComponent.isMention(node)) {\n        const before = document.createTextNode(ZWS);\n        const after = document.createTextNode(ZWS);\n        range.insertNode(before);\n        range.setStartAfter(before);\n        range.insertNode(node);\n        range.setStartAfter(node);\n        range.insertNode(after);\n        range.setStartAfter(after);\n        cursorTarget = after;\n      } else {\n        range.insertNode(node);\n        range.setStartAfter(node);\n        cursorTarget = node;\n      }\n      range.collapse(true);\n    }\n\n    // After a mention, leave the cursor inside the trailing ZWS so ArrowLeft\n    // can step back to before-the-mention naturally.\n    if (cursorTarget && MentionsInputComponent.isZws(cursorTarget)) {\n      range.setStart(cursorTarget, 0);\n      range.collapse(true);\n    }\n\n    selection.removeAllRanges();\n    selection.addRange(range);\n  }\n\n  private insertLineBreak(): void {\n    const selection = window.getSelection();\n    if (!selection?.rangeCount || !this.inputElement?.nativeElement) {\n      return;\n    }\n    const range = selection.getRangeAt(0);\n    range.deleteContents();\n\n    const br = document.createElement('br');\n    range.insertNode(br);\n    range.setStartAfter(br);\n    range.collapse(true);\n\n    // A trailing <br> alone doesn't render an empty line in contenteditable —\n    // a ZWS gives the caret a place to land.\n    if (!br.nextSibling) {\n      const zws = document.createTextNode(ZWS);\n      range.insertNode(zws);\n      range.setStart(zws, 0);\n      range.collapse(true);\n    }\n\n    selection.removeAllRanges();\n    selection.addRange(range);\n  }\n\n  // ─── Mention trigger / dropdown ────────────────────────────────────────\n\n  private checkForMentionTrigger(): void {\n    const selection = window.getSelection();\n    if (!selection || !selection.rangeCount || !this.inputElement) {\n      return;\n    }\n\n    const range = selection.getRangeAt(0);\n    const textBeforeCursor = this.getTextBeforeCursor(range);\n    const lastAtIndex = textBeforeCursor.lastIndexOf('@');\n\n    if (lastAtIndex === -1) {\n      this.closeMentions();\n      return;\n    }\n    //If we allow for a single space, we need to check to make sure that this logic won't pick up previous\n    //'@' mentions and keep the mention dropdown open\n    const atPosition = this.findDomPositionAtCharIndex(lastAtIndex);\n    if (atPosition && this.isInsideMentionSpan(atPosition.node)) {\n      this.closeMentions();\n      return;\n    }\n\n    const textAfterAt = textBeforeCursor.substring(lastAtIndex + 1);\n    const char1 = textAfterAt.charCodeAt(0);\n    const charN = textAfterAt.charCodeAt(textAfterAt.length - 1);\n    const charN_1 = textAfterAt.charCodeAt(textAfterAt.length - 2);\n    //These are the Unicode representations of normal space and non-breaking space\n    const unicodeSpaceChars = [32, 160];\n\n    // Close mentions if:\n    // - There's a double space (allows single spaces in the middle of search)\n    // - The text starts with a space (typing \"@ \" should not trigger mentions)\n    if (\n      textAfterAt.includes('  ') ||\n      textAfterAt.startsWith(' ') ||\n      char1 == 160 ||\n      (unicodeSpaceChars.includes(charN) && unicodeSpaceChars.includes(charN_1))\n    ) {\n      this.closeMentions();\n      return;\n    }\n    // Trim trailing/leading spaces from search text while preserving spaces in the middle\n    this.mentionSearchText = textAfterAt.trim();\n    // Only show mentions if there are filtered users\n    const filteredUsers = this.getFilteredUsers();\n    if (filteredUsers.length === 0) {\n      this.closeMentions();\n      return;\n    }\n\n    this.mentionsVisible = true;\n    this.selectedUserIndex = 0;\n\n    //Save the current range for later restoration (needed for click selection)\n    //DAHNE NOTE - this is annoyingly neceessary because clicks and enter keys have different effects on the\n    //focus of the contenteditable div\n    this.savedRange = range.cloneRange();\n\n    if (atPosition) {\n      const atRange = document.createRange();\n      atRange.setStart(atPosition.node, atPosition.offset);\n      atRange.setEnd(atPosition.node, atPosition.offset + 1);\n      this.mentionAnchor = atRange.getBoundingClientRect();\n    }\n    this.cdr.markForCheck();\n  }\n\n  private getTextBeforeCursor(range: Range): string {\n    const clonedRange = range.cloneRange();\n    //We select all of the input contents, and then move the end point to the current cursor position\n    clonedRange.selectNodeContents(this.inputElement!.nativeElement);\n    clonedRange.setEnd(range.endContainer, range.endOffset);\n    //Create a temporary div so that we can extract text content from it\n    const fragment = clonedRange.cloneContents();\n    const div = document.createElement('div');\n    div.appendChild(fragment);\n    //Get text content, replacing mention spans with @name\n    return div.textContent || '';\n  }\n\n  getFilteredUsers(): MentionsInputComponent.User[] {\n    const users = !this.mentionSearchText\n      ? this.users\n      : this.users.filter(user =>\n          user.name\n            .toLowerCase()\n            .includes(this.mentionSearchText.toLowerCase()),\n        );\n    return users.slice().sort((a, b) => a.name.localeCompare(b.name));\n  }\n\n  onUserHover(index: number): void {\n    this.selectedUserIndex = index;\n    this.cdr.markForCheck();\n  }\n\n  selectUser(user: MentionsInputComponent.User): void {\n    if (!this.inputElement) {\n      return;\n    }\n    //This gets DOM info from user (e.g. highlighted selections, and cursor position)\n    const selection = window.getSelection();\n    if (!selection) {\n      return;\n    }\n    // Restore the saved range if available (needed when selecting via click)\n    if (this.savedRange) {\n      selection.removeAllRanges();\n      selection.addRange(this.savedRange);\n    }\n    if (!selection.rangeCount) {\n      return;\n    }\n    // Delete the \"@\" and search text\n    this.deleteAtMentionSearch();\n\n    //DAHNE NOTE - this would ideally be the same as contentItemToHTML, but we need an actual element reference here in order to append it to the DOM\n    const mentionSpan = document.createElement('span');\n    mentionSpan.className = this.readonly ? 'readonly-mention' : 'mention';\n    mentionSpan.setAttribute('data-id', String(user.id));\n    mentionSpan.setAttribute('data-type', 'mention');\n    mentionSpan.setAttribute('contenteditable', 'false');\n    mentionSpan.textContent = `@${user.name}`;\n\n    this.insertNodesAtCursor([mentionSpan, document.createTextNode(' ')]);\n    this.normalizeMentionPadding();\n\n    this.closeMentions();\n    this.emitContentChange();\n  }\n\n  private deleteAtMentionSearch(): void {\n    const selection = window.getSelection();\n    if (!selection || !selection.rangeCount) {\n      return;\n    }\n    //This represents the current position of the cursor\n    const cursorRange = selection.getRangeAt(0);\n    //This will return all of the raw text (HTML-stripped) before the cursor\n    const textBeforeCursor = this.getTextBeforeCursor(cursorRange);\n    //We do that^ so that we can find the correct index of the most recent '@'\n    const lastAtIndex = textBeforeCursor.lastIndexOf('@');\n\n    if (lastAtIndex === -1) {\n      return;\n    }\n    const atPosition = this.findDomPositionAtCharIndex(lastAtIndex);\n    if (!atPosition) {\n      return;\n    }\n    // Create range from \"@\" to cursor and delete it\n    const deleteRange = document.createRange();\n    deleteRange.setStart(atPosition.node, atPosition.offset);\n    deleteRange.setEnd(cursorRange.endContainer, cursorRange.endOffset);\n    deleteRange.deleteContents();\n  }\n\n  private isInsideMentionSpan(node: Node): boolean {\n    let currentNode: Node | null = node;\n    while (currentNode && currentNode !== this.inputElement?.nativeElement) {\n      if (MentionsInputComponent.isMention(currentNode)) {\n        return true;\n      }\n      currentNode = currentNode.parentNode;\n    }\n    return false;\n  }\n  //This will go text node by node looking for the\n  //@ mention and give its position in the context of that node\n  private findDomPositionAtCharIndex(\n    charIndex: number,\n  ): { node: Node; offset: number } | null {\n    if (!this.inputElement) {\n      return null;\n    }\n    // Walk through all text nodes in the input, counting characters\n    const treeWalker = document.createTreeWalker(\n      this.inputElement.nativeElement,\n      NodeFilter.SHOW_TEXT,\n      null,\n    );\n    let charCount = 0;\n    while (treeWalker.nextNode()) {\n      const node = treeWalker.currentNode;\n      const text = node.textContent || '';\n      // Check if our target character is in this text node\n      if (charCount + text.length > charIndex) {\n        return { node, offset: charIndex - charCount };\n      }\n      charCount += text.length;\n    }\n    return null;\n  }\n\n  private closeMentions(): void {\n    this.mentionsVisible = false;\n    this.mentionSearchText = '';\n    this.mentionAnchor = null;\n    this.selectedUserIndex = 0;\n    this.savedRange = null;\n    this.cdr.markForCheck();\n  }\n\n  private emitContentChange(): void {\n    if (!this.inputElement) {\n      return;\n    }\n    this.contentChange.emit(this.domToContentItems());\n  }\n\n  private domToContentItems(): MentionsInputComponent.ContentItem[] {\n    if (!this.inputElement?.nativeElement) {\n      return [];\n    }\n    const items: MentionsInputComponent.ContentItem[] = [];\n    const childNodes = this.inputElement.nativeElement.childNodes;\n\n    for (const node of Array.from(childNodes)) {\n      if (node.nodeType === Node.ELEMENT_NODE) {\n        const element = node as HTMLElement;\n        if (\n          element.tagName === 'SPAN' &&\n          element.getAttribute('data-type') === 'mention'\n        ) {\n          const id = Number(element.getAttribute('data-id'));\n          const name = element.textContent?.replace('@', '') || '';\n          items.push({ type: 'mention', id, name });\n        } else if (element.tagName === 'BR') {\n          items.push({ type: 'newline' });\n        }\n      } else if (node.nodeType === Node.TEXT_NODE) {\n        // ZWS pads are a DOM affordance — they shouldn't leak into the data model.\n        const text = (node.textContent || '').replace(ZWS_REGEX, '');\n        if (text) {\n          items.push({ type: 'text', text });\n        }\n      }\n    }\n    return items;\n  }\n\n  onCalloutClose(): void {\n    this.closeMentions();\n  }\n}\n\nexport namespace MentionsInputComponent {\n  export const ContentTypes = ['mention', 'text', 'newline'] as const;\n  export type ContentType =\n    (typeof MentionsInputComponent.ContentTypes)[number];\n  export interface User {\n    id: number;\n    name: string;\n  }\n  export type Content<T extends ContentType> = { type: T };\n\n  export type UserMention = Content<'mention'> & User;\n  export type Text = Content<'text'> & { text: string };\n  export type Newline = Content<'newline'>;\n\n  export type ContentItem = UserMention | Text | Newline;\n\n  export function contentToPlainText(content: ContentItem[]): string {\n    return content\n      .map(item => {\n        switch (item.type) {\n          case 'mention':\n            return `@${item.name}`;\n          case 'text':\n            return item.text;\n          case 'newline':\n            return '\\n';\n        }\n      })\n      .join('');\n  }\n}\n","<div class=\"mentions-container\" #container>\n  <div\n    *ngIf=\"!readonly\"\n    #input\n    class=\"text-content editable\"\n    contenteditable=\"true\"\n    [attr.data-placeholder]=\"placeholder\"\n    (input)=\"onInput()\"\n    (keydown)=\"onKeyDown($event)\"\n    (paste)=\"onPaste($event)\"\n    (copy)=\"onCopy($event)\"\n    (cut)=\"onCut($event)\"\n  ></div>\n\n  <div *ngIf=\"readonly\" #input class=\"text-content\"></div>\n\n  <riv-callout\n    *ngIf=\"!readonly && mentionsVisible && mentionAnchor\"\n    [anchor]=\"mentionAnchor\"\n    [isModal]=\"true\"\n    [showCaret]=\"false\"\n    [allowedPositions]=\"['bottom-right', 'top-right']\"\n    [theme]=\"'light'\"\n    (close)=\"onCalloutClose()\"\n  >\n    <div class=\"mentions-content\">\n      <div class=\"mentions-header\">Mention someone</div>\n      <div class=\"mentions-list\">\n        <button\n          type=\"button\"\n          *ngFor=\"let user of getFilteredUsers(); let i = index\"\n          [class.selected]=\"i === selectedUserIndex\"\n          (mouseenter)=\"onUserHover(i)\"\n          (click)=\"selectUser(user)\"\n        >\n          {{ user.name }}\n        </button>\n      </div>\n    </div>\n  </riv-callout>\n</div>\n"]}