@rowsncolumns/ui 15.0.38

package/dist/esm/editor-pm/helpers.js

@@ -0,0 +1,1113 @@
+import { cleanupColumnName } from "@rowsncolumns/calculator";
+import { tokenVocabulary } from "@rowsncolumns/fast-formula-parser";
+import { CELL_SUGGESTION_PREFIX, CELL_SUGGESTION_SUFFIX, } from "../editor/constants";
+/**
+ * Converts string to ProseMirror document
+ * @param str
+ * @param schema
+ * @returns
+ */
+export const deserializeString = (str, schema) => {
+    try {
+        if (typeof str === "object") {
+            str = tryParseRichText(str);
+        }
+        // Validate input
+        if (typeof str !== "string") {
+            console.warn("deserializeString: input is not a string, using empty string");
+            str = "";
+        }
+        // Sanitize string - remove null characters and other problematic chars
+        str = str
+            .replace(/\0/g, "")
+            .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+        const lines = str.split("\n");
+        const nodes = lines.map((line) => schema.node("line", null, line ? [schema.text(line)] : []));
+        return schema.node("doc", null, nodes);
+    }
+    catch (error) {
+        console.error("Error deserializing string:", error);
+        // Return empty document as fallback
+        return schema.node("doc", null, [schema.node("line", null, [])]);
+    }
+};
+export const tryParseRichText = (str) => {
+    // Temporary workaround for .richText
+    if ("richText" in str) {
+        str = str?.richText?.map((value) => value.text).join("");
+    }
+    else {
+        str = "Unable to parse string";
+    }
+    return str;
+};
+/**
+ * Converts ProseMirror document to string
+ * @param doc
+ * @returns
+ */
+export const serializeEditorValue = (doc) => {
+    let text = "";
+    doc.content.forEach((node, offset, index) => {
+        if (node.type.name === "line") {
+            if (index > 0)
+                text += "\n";
+            // Serialize line content, handling mention nodes properly
+            let lineText = "";
+            node.content.forEach((child) => {
+                if (child.type.name === "mention") {
+                    // Serialize mention as just the label
+                    lineText += child.attrs.label;
+                }
+                else if (child.isText) {
+                    // Regular text node
+                    lineText += child.text;
+                }
+            });
+            text += lineText;
+        }
+    });
+    return text;
+};
+/**
+ * Extracts text format runs from ProseMirror document
+ * @param doc ProseMirror document node
+ * @returns Array of TextFormatRun objects
+ */
+export const extractTextFormatRuns = (doc) => {
+    if (!doc) {
+        return undefined;
+    }
+    const formatRuns = [];
+    let currentIndex = 0;
+    doc.content.forEach((node, _, lineIndex) => {
+        if (node.type.name === "line") {
+            if (lineIndex > 0) {
+                // Add newline character to index
+                currentIndex++;
+            }
+            // First pass: collect all child nodes with their start positions
+            const childNodes = [];
+            let nodeIndex = currentIndex;
+            node.content.forEach((child) => {
+                childNodes.push({
+                    node: child,
+                    startIndex: nodeIndex,
+                });
+                // Calculate the next start index based on the node type
+                if (child.type.name === "mention") {
+                    // For mentions, use just the label length for positioning
+                    nodeIndex += child.attrs.label.length;
+                }
+                else if (child.isText && child.text) {
+                    nodeIndex += child.text.length;
+                }
+            });
+            // Second pass: create format runs using next child's start index as end boundary
+            childNodes.forEach((childData, index) => {
+                const { node: child, startIndex } = childData;
+                // Calculate endIndex using next child's startIndex, or end of line
+                const nextChild = childNodes[index + 1];
+                const endIndex = nextChild ? nextChild.startIndex : nodeIndex;
+                if (child.type.name === "mention") {
+                    formatRuns.push({
+                        startIndex,
+                        endIndex,
+                        nodeType: "mention",
+                        mention: { ...child.attrs },
+                    });
+                }
+                else if (child.isText && child.text) {
+                    if (child.marks && child.marks.length > 0) {
+                        // Extract format from marks
+                        const format = {};
+                        child.marks.forEach((mark) => {
+                            switch (mark.type.name) {
+                                case "bold":
+                                    format.bold = true;
+                                    break;
+                                case "italic":
+                                    format.italic = true;
+                                    break;
+                                case "underline":
+                                    format.underline = true;
+                                    break;
+                                case "strikethrough":
+                                    format.strikethrough = true;
+                                    break;
+                                case "superscript":
+                                    format.baselineOffset = "superscript";
+                                    break;
+                                case "subscript":
+                                    format.baselineOffset = "subscript";
+                                    break;
+                                case "color":
+                                    format.color = mark.attrs.color;
+                                    break;
+                                case "fontSize":
+                                    format.fontSize = mark.attrs.size;
+                                    break;
+                                case "fontFamily":
+                                    format.fontFamily = mark.attrs.family;
+                                    break;
+                            }
+                        });
+                        formatRuns.push({
+                            startIndex,
+                            endIndex,
+                            format,
+                            nodeType: "text",
+                        });
+                    }
+                    else {
+                        // Plain text without formatting
+                        formatRuns.push({
+                            startIndex,
+                            endIndex,
+                            format: {},
+                            nodeType: "text",
+                        });
+                    }
+                }
+            });
+            currentIndex = nodeIndex;
+        }
+    });
+    // Filter out text nodes with empty format objects
+    const filteredRuns = formatRuns.filter((run) => {
+        if (run.nodeType === "text" && Object.keys(run.format).length === 0) {
+            return false;
+        }
+        return true;
+    });
+    return filteredRuns.length === 0 ? undefined : filteredRuns;
+};
+export const applyTextFormatRuns = (text, formatRuns, schema, resolveColor) => {
+    // Handle empty text case
+    if (text === "") {
+        return schema.nodes.doc.create(null, [schema.nodes.line.create(null, [])]);
+    }
+    // If no format runs, create simple document with plain text
+    if (!formatRuns || formatRuns?.length === 0) {
+        const lines = text.split("\n");
+        const lineNodes = lines.map((lineText) => schema.nodes.line.create(null, lineText ? [schema.text(lineText)] : []));
+        return schema.nodes.doc.create(null, lineNodes);
+    }
+    const sortedFormatRuns = [...formatRuns].sort((a, b) => a.startIndex - b.startIndex || a.endIndex - b.endIndex);
+    const createMarks = (formatRun) => {
+        const marks = [];
+        // Engine-emitted runs (rnc window cells) can omit `format` on the
+        // unformatted gap runs between styled spans.
+        if (!formatRun.format) {
+            return marks;
+        }
+        if (formatRun.format.bold) {
+            marks.push(schema.marks.bold.create());
+        }
+        if (formatRun.format.italic) {
+            marks.push(schema.marks.italic.create());
+        }
+        if (formatRun.format.underline) {
+            marks.push(schema.marks.underline.create());
+        }
+        if (formatRun.format.strikethrough) {
+            marks.push(schema.marks.strikethrough.create());
+        }
+        if (formatRun.format.color) {
+            const css = typeof formatRun.format.color === "string"
+                ? formatRun.format.color
+                : resolveColor?.(formatRun.format.color);
+            if (css) {
+                marks.push(schema.marks.color.create({ color: css }));
+            }
+        }
+        if (formatRun.format.baselineOffset === "superscript") {
+            marks.push(schema.marks.superscript.create());
+        }
+        else if (formatRun.format.baselineOffset === "subscript") {
+            marks.push(schema.marks.subscript.create());
+        }
+        if (formatRun.format.fontSize != null) {
+            marks.push(schema.marks.fontSize.create({ size: formatRun.format.fontSize }));
+        }
+        if (formatRun.format.fontFamily) {
+            marks.push(schema.marks.fontFamily.create({ family: formatRun.format.fontFamily }));
+        }
+        return marks;
+    };
+    // Split text into lines
+    const lines = text.split("\n");
+    const lineNodes = [];
+    let currentTextIndex = 0;
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const lineText = lines[lineIndex];
+        const lineContent = [];
+        if (lineIndex > 0) {
+            // Account for newline character
+            currentTextIndex++;
+        }
+        const lineStartIndex = currentTextIndex;
+        const lineEndIndex = currentTextIndex + lineText.length;
+        // Get format runs that overlap this line. Runs may span newlines,
+        // but ProseMirror stores each line separately, so split by line.
+        const lineFormatRuns = sortedFormatRuns.filter((run) => run.startIndex < lineEndIndex && run.endIndex > lineStartIndex);
+        if (lineFormatRuns.length === 0 && lineText.length > 0) {
+            // No formatting, create plain text node
+            lineContent.push(schema.text(lineText));
+        }
+        else if (lineText.length > 0) {
+            // Process format runs for this line
+            let processedIndex = lineStartIndex;
+            for (const formatRun of lineFormatRuns) {
+                const runStart = Math.max(formatRun.startIndex, lineStartIndex);
+                const runEnd = Math.min(formatRun.endIndex, lineEndIndex);
+                if (runEnd <= runStart || processedIndex >= lineEndIndex) {
+                    continue;
+                }
+                // Add any unformatted text before this run
+                if (processedIndex < runStart) {
+                    const unformattedText = text.substring(processedIndex, runStart);
+                    if (unformattedText) {
+                        lineContent.push(schema.text(unformattedText));
+                    }
+                }
+                if (formatRun.nodeType === "mention") {
+                    // Create mention node from format run data
+                    if (formatRun.mention && formatRun.startIndex >= lineStartIndex) {
+                        lineContent.push(schema.nodes.mention.create({
+                            label: formatRun.mention.label,
+                            value: formatRun.mention.value,
+                        }));
+                        // Since mentions are now stored as just the label, advance by label length
+                        processedIndex = runStart + formatRun.mention.label.length;
+                    }
+                }
+                else {
+                    // Any non-mention run is a text run. xlsx-imported runs (rnc
+                    // engine and excel-parser) omit `nodeType`, so an exact
+                    // `=== "text"` check skipped them entirely — processedIndex
+                    // never advanced and the gap/tail fillers re-emitted the
+                    // already-covered text (e.g. "kpmg" painting as "kpmgkpmg").
+                    const runText = text.substring(Math.max(processedIndex, runStart), runEnd);
+                    if (runText) {
+                        lineContent.push(schema.text(runText, createMarks(formatRun)));
+                        processedIndex = runEnd;
+                    }
+                }
+            }
+            // Add any remaining unformatted text at the end of the line
+            if (processedIndex < lineEndIndex) {
+                const remainingText = text.substring(processedIndex, lineEndIndex);
+                if (remainingText) {
+                    lineContent.push(schema.text(remainingText));
+                }
+            }
+        }
+        // Create line node
+        lineNodes.push(schema.nodes.line.create(null, lineContent));
+        currentTextIndex += lineText.length;
+    }
+    // Create document
+    return schema.nodes.doc.create(null, lineNodes);
+};
+/**
+ * Applies a `TextFormat` patch to the editor's CURRENT SELECTION as marks —
+ * the per-run counterpart of the toolbar's cell-level `onChangeFormatting`.
+ * This is what makes the toolbar's bold/superscript/font-size controls format
+ * just the selected span while the cell editor is open, the way Cmd+B already
+ * does through the keymap.
+ *
+ * Semantics per key (only keys PRESENT on `format` are touched):
+ * - `bold`/`italic`/`underline`/`strikethrough`: TOGGLE against the
+ *   selection's own mark state (same rule as prosemirror-commands
+ *   `toggleMark`: any marked text in range → remove, else add) — the caller's
+ *   cell-level boolean is ignored because it describes the cell, not the span.
+ * - `baselineOffset`: if the selection already carries the target offset the
+ *   pair is cleared; otherwise the target replaces both (mutually exclusive).
+ * - `fontSize`/`fontFamily`/`color`: SET to the given value (clear on nullish).
+ *   Theme-object colors resolve through `resolveColor`.
+ *
+ * A collapsed selection applies the change to the stored marks, so it affects
+ * what is typed next — Google Sheets behavior.
+ *
+ * Returns `false` (and dispatches nothing) when `format` carries none of the
+ * run-representable keys, so the caller can fall back to cell-level formatting.
+ */
+export const applyTextFormatToSelection = (state, dispatch, format, schema, resolveColor) => {
+    const { from, to, empty } = state.selection;
+    const cursorMarks = state.storedMarks ?? state.selection.$from.marks();
+    let tr = state.tr;
+    let handled = false;
+    const hasMark = (markType) => empty
+        ? markType.isInSet(cursorMarks) != null
+        : state.doc.rangeHasMark(from, to, markType);
+    const add = (mark) => {
+        tr = empty ? tr.addStoredMark(mark) : tr.addMark(from, to, mark);
+    };
+    const remove = (markType) => {
+        tr = empty ? tr.removeStoredMark(markType) : tr.removeMark(from, to, markType);
+    };
+    for (const key of ["bold", "italic", "underline", "strikethrough"]) {
+        if (!(key in format))
+            continue;
+        handled = true;
+        const markType = schema.marks[key];
+        if (hasMark(markType)) {
+            remove(markType);
+        }
+        else {
+            add(markType.create());
+        }
+    }
+    if ("baselineOffset" in format) {
+        handled = true;
+        const target = format.baselineOffset;
+        const targetType = target ? schema.marks[target] : undefined;
+        const alreadyOn = targetType ? hasMark(targetType) : false;
+        remove(schema.marks.superscript);
+        remove(schema.marks.subscript);
+        if (targetType && !alreadyOn) {
+            add(targetType.create());
+        }
+    }
+    if ("fontSize" in format) {
+        handled = true;
+        remove(schema.marks.fontSize);
+        if (format.fontSize != null) {
+            add(schema.marks.fontSize.create({ size: format.fontSize }));
+        }
+    }
+    if ("fontFamily" in format) {
+        handled = true;
+        remove(schema.marks.fontFamily);
+        if (format.fontFamily) {
+            add(schema.marks.fontFamily.create({ family: format.fontFamily }));
+        }
+    }
+    if ("color" in format) {
+        handled = true;
+        remove(schema.marks.color);
+        const css = typeof format.color === "string"
+            ? format.color
+            : format.color
+                ? resolveColor?.(format.color)
+                : undefined;
+        if (css) {
+            add(schema.marks.color.create({ color: css }));
+        }
+    }
+    if (!handled) {
+        return false;
+    }
+    dispatch?.(tr);
+    return true;
+};
+/**
+ * Effective fontSize (pt) of the current selection, or `null` when the
+ * selection carries no fontSize mark. A collapsed selection reads the stored
+ * marks (what the next typed character would get); a range reads the marks of
+ * the first text node in the range, matching how the run is rendered.
+ */
+export const getSelectionFontSize = (state) => {
+    const { from, to, empty } = state.selection;
+    let marks = null;
+    if (empty) {
+        marks = state.storedMarks ?? state.selection.$from.marks();
+    }
+    else {
+        state.doc.nodesBetween(from, to, (node) => {
+            if (marks)
+                return false;
+            if (node.isText) {
+                marks = node.marks;
+                return false;
+            }
+            return true;
+        });
+    }
+    const mark = marks?.find((m) => m.type.name === "fontSize");
+    const size = mark?.attrs?.size;
+    return typeof size === "number" && Number.isFinite(size) ? size : null;
+};
+/**
+ * Get current cursor position
+ * @param state
+ * @returns
+ */
+export const getCursorPosition = (state) => {
+    try {
+        const { selection } = state;
+        if (!selection || !selection.empty) {
+            return undefined;
+        }
+        // Bounds checking
+        const pos = selection.from;
+        if (pos < 0 || pos > state.doc.content.size) {
+            console.warn(`Invalid cursor position: ${pos}, doc size: ${state.doc.content.size}`);
+            return undefined;
+        }
+        return pos;
+    }
+    catch (error) {
+        console.warn("Error getting cursor position:", error);
+        return undefined;
+    }
+};
+/**
+ * Get currently focused token
+ * @param position
+ * @param tokens
+ * @returns
+ */
+export const getActiveToken = (position, tokens) => {
+    return tokens.find((token) => token.endColumn >= position);
+};
+export const enableCellSelection = (position, cursorPos, tokens) => {
+    if (!Number.isFinite(cursorPos) || !tokens.length) {
+        return false;
+    }
+    const [prev, active, next] = getSurroundingTokens(position, tokens);
+    const isStringLike = (token) => !!token &&
+        (token.tokenType.name === tokenVocabulary.String.name ||
+            token.tokenType.name === tokenVocabulary.UnterminatedStringStart.name ||
+            token.image === '"');
+    const isCoveringPosition = (token) => isStringLike(token) &&
+        position >= (token?.startColumn ?? position) &&
+        position <= (token?.endColumn ?? position);
+    if (isStringLike(active) || isStringLike(next) || isCoveringPosition(prev)) {
+        return false;
+    }
+    const isEmptyFunctionCall = prev?.tokenType.name === tokenVocabulary.Function.name &&
+        active?.tokenType.name === tokenVocabulary.CloseParen.name &&
+        (prev.image ?? "").endsWith("(") &&
+        (active.startColumn ?? 0) === (prev.endColumn ?? -1) + 1;
+    if (isEmptyFunctionCall) {
+        return false;
+    }
+    const isAfterCloseParen = active?.tokenType.name === tokenVocabulary.CloseParen.name &&
+        cursorPos === position + 1;
+    if (isAfterCloseParen) {
+        return false;
+    }
+    const prevAllowed = prev &&
+        CELL_SUGGESTION_PREFIX.includes(prev.tokenType.name) &&
+        position > (prev.endColumn ?? -Infinity);
+    // The cursor must actually be inside (or at the trailing edge of) the
+    // active token for it to count as the prefix that enables cell
+    // selection. Without the `position >= startColumn` guard, a cursor
+    // positioned BEFORE the active token (e.g. caret at index 0 of `=$12`)
+    // would still treat the leading `=` as the prefix and flip the editor
+    // into cell-suggestion mode. Calculator columns are 1-indexed while
+    // `position` (offsetInLine) is 0-indexed, so cursor-just-before-token
+    // satisfies `position < startColumn`.
+    const activeAllowed = active &&
+        CELL_SUGGESTION_PREFIX.includes(active.tokenType.name) &&
+        position >= (active.startColumn ?? Infinity) &&
+        position <= (active.endColumn ?? position);
+    const prefixToken = prevAllowed ? prev : activeAllowed ? active : undefined;
+    if (!prefixToken) {
+        return false;
+    }
+    const isActiveReferenceStart = active &&
+        isReferenceToken(active) &&
+        position + 1 === (active.startColumn ?? position + 1);
+    if (isActiveReferenceStart) {
+        return false;
+    }
+    const isNextReferenceStart = next &&
+        isReferenceToken(next) &&
+        position + 1 === (next.startColumn ?? position + 1);
+    if (isNextReferenceStart) {
+        return false;
+    }
+    if (next && !CELL_SUGGESTION_SUFFIX.includes(next.tokenType.name)) {
+        return false;
+    }
+    const activeType = active?.tokenType?.name;
+    const isInsideReference = isReferenceToken(active) &&
+        position >= (active?.startColumn ?? position) &&
+        position <= (active?.endColumn ?? position);
+    let isInsideFunctionName = false;
+    if (activeType === tokenVocabulary.Function.name && active) {
+        const start = active.startColumn ?? position;
+        let nameEnd = active.endColumn ?? position;
+        const image = active.image ?? "";
+        if (image.endsWith("(") && image.length > 1) {
+            const nameLength = image.length - 1;
+            nameEnd = start + nameLength - 1;
+        }
+        isInsideFunctionName = position >= start && position <= nameEnd;
+    }
+    if (isInsideReference ||
+        isInsideFunctionName ||
+        activeType === tokenVocabulary.String.name ||
+        activeType === tokenVocabulary.UnterminatedStringStart.name ||
+        activeType === tokenVocabulary.Number.name ||
+        activeType === tokenVocabulary.Boolean.name) {
+        return false;
+    }
+    return true;
+};
+/**
+ * Get prev, current and next tokens using a position
+ * @param position
+ * @param tokens
+ * @returns
+ */
+export const getSurroundingTokens = (position, tokens) => {
+    const activeToken = getActiveToken(position, tokens);
+    return [
+        getPreviousToken(position, tokens),
+        activeToken,
+        getNextToken(position, tokens, activeToken),
+    ];
+};
+/**
+ * Get the previous token from the current position
+ * @param position
+ * @param tokens
+ * @returns
+ */
+export const getPreviousToken = (position, tokens) => {
+    let previous;
+    for (const token of tokens) {
+        if (token.endColumn < position) {
+            previous = token;
+            continue;
+        }
+        if (token.startColumn <= position && token.endColumn >= position) {
+            return previous;
+        }
+        if (token.startColumn > position) {
+            break;
+        }
+    }
+    return previous;
+};
+/**
+ * Get next token from position
+ * @param position
+ * @param tokens
+ * @returns
+ */
+export const getNextToken = (position, tokens, activeToken) => {
+    return tokens.find((token) => {
+        if (activeToken && token === activeToken) {
+            return false;
+        }
+        const start = token.startColumn && token.startColumn > 0
+            ? token.startColumn - 1
+            : token.startOffset;
+        return start !== undefined && start >= position;
+    });
+};
+/**
+ * Is current token a cell token
+ * @param token
+ * @returns
+ */
+export const isCellToken = (token) => token.tokenType.name === tokenVocabulary.Cell.name || token.selection;
+export const isTableColumnToken = (token) => token.tokenType.name === tokenVocabulary.TableColumnName.name;
+export const isTableNameToken = (token) => token.tokenType.name === tokenVocabulary.TableName.name;
+export const isNamedRangeToken = (token) => token.tokenType.name === tokenVocabulary.Name.name;
+export const isStringToken = (token) => token.tokenType.name === tokenVocabulary.String.name;
+export const isNumberToken = (token) => token.tokenType.name === tokenVocabulary.Number.name;
+const isReferenceToken = (token) => {
+    if (!token)
+        return false;
+    return (isCellToken(token) ||
+        isTableColumnToken(token) ||
+        isTableNameToken(token) ||
+        isNamedRangeToken(token) ||
+        token.tokenType.name === tokenVocabulary.Column.name);
+};
+/**
+ * Check if token is a cell reference with property (e.g., A1.title or A1.)
+ * @param token
+ * @returns
+ */
+export const getPropertyStartIndex = (token) => {
+    if (!token?.image) {
+        return -1;
+    }
+    if (token.tokenType.name === tokenVocabulary.Cell.name ||
+        token.tokenType.name === tokenVocabulary.Name.name) {
+        return token.image.indexOf(".");
+    }
+    if (token.tokenType.name === tokenVocabulary.TableColumnName.name ||
+        token.tokenType.name === tokenVocabulary.SpecialItem.name ||
+        token.tokenType.name === tokenVocabulary.TableName.name) {
+        const lastClosingBracket = token.image.lastIndexOf("]");
+        if (lastClosingBracket === -1) {
+            return -1;
+        }
+        return token.image.indexOf(".", lastClosingBracket + 1);
+    }
+    return -1;
+};
+export const hasPropertyReference = (token) => {
+    const index = getPropertyStartIndex(token);
+    return index !== -1;
+};
+/**
+ * Get current active function
+ * @param curToken
+ * @param tokens
+ */
+export const getActiveFunctionToken = (curToken, tokens) => {
+    if (!curToken)
+        return void 0;
+    let i = tokens.findIndex((token) => token === curToken);
+    let fn;
+    let skip = 0;
+    while (i > 0) {
+        const token = tokens[i];
+        if (token.tokenType.name === tokenVocabulary.CloseParen.name) {
+            skip++;
+        }
+        if (token.tokenType.name === tokenVocabulary.Function.name) {
+            if (skip > 0) {
+                skip--;
+            }
+            else {
+                fn = token;
+                break;
+            }
+        }
+        i--;
+    }
+    return fn;
+};
+/**
+ * get selection index from activetoken
+ * @param activeToken
+ * @returns
+ */
+export const getActiveSelectionIndex = (activeToken) => {
+    return activeToken?.structured ||
+        activeToken?.isNamedRange ||
+        activeToken?.selection
+        ? activeToken.index ?? -1
+        : -1;
+};
+/**
+ * Suggestion token
+ * @param position
+ * @param activeToken
+ * @param view
+ * @returns
+ */
+export const getActiveSuggestionToken = (position, activeToken, view) => {
+    // If the token is already a function, lets ignore
+    if (!activeToken ||
+        activeToken.tokenType.name === tokenVocabulary.Function.name) {
+        return undefined;
+    }
+    const propertyStart = hasPropertyReference(activeToken)
+        ? getPropertyStartIndex(activeToken)
+        : -1;
+    if (propertyStart !== -1 && activeToken?.image != null) {
+        const propertyImage = activeToken.image.slice(propertyStart + 1);
+        const propertyStartOffset = (activeToken.startOffset ?? 0) + propertyStart + 1;
+        const propertyStartColumn = (activeToken.startColumn ?? 0) + propertyStart + 1;
+        const suggestionToken = {
+            ...activeToken,
+            image: propertyImage,
+            startOffset: propertyStartOffset,
+            endOffset: propertyStartOffset + propertyImage.length,
+            startColumn: propertyStartColumn,
+            endColumn: propertyStartColumn + propertyImage.length,
+        };
+        suggestionToken.basePropertyToken = activeToken;
+        return suggestionToken;
+    }
+    // Named ranges.
+    // Resolved named ranges have `index` property. If its resolved,
+    // lets not show suggestions anymore
+    if (activeToken.tokenType.name === tokenVocabulary.Name.name &&
+        activeToken.index !== undefined) {
+        return undefined;
+    }
+    // For tables
+    if (activeToken.tokenType.name === tokenVocabulary.TableName.name ||
+        activeToken.tokenType.name === tokenVocabulary.TableColumnName.name) {
+        try {
+            const result = getWordAtPosition(view.state, position);
+            if (result?.end === position) {
+                return undefined;
+            }
+            // Use the token's image directly for cleanup
+            // This avoids complex ProseMirror position calculations
+            const tokenImage = activeToken.image || "";
+            const tableNameLength = activeToken.tableName
+                ? activeToken.tableName.length + 1
+                : 0;
+            if (!tokenImage) {
+                return undefined;
+            }
+            const cleanupImage = cleanupColumnName(tokenImage);
+            const change = tokenImage.length - cleanupImage.length;
+            return {
+                ...activeToken,
+                startOffset: activeToken.startOffset + tableNameLength + change,
+                image: cleanupImage,
+            };
+        }
+        catch (error) {
+            console.warn("Error processing table suggestion token:", error);
+            return activeToken;
+        }
+    }
+    return activeToken.tokenType.name === tokenVocabulary.TableColumnName.name ||
+        activeToken.tokenType.name === tokenVocabulary.Column.name ||
+        activeToken.tokenType.name === tokenVocabulary.Name.name ||
+        activeToken.tokenType.name === tokenVocabulary.Function.name ||
+        activeToken.tokenType.name === tokenVocabulary.UnterminatedStringStart.name
+        ? activeToken
+        : undefined;
+};
+export const resolveCellPropertyToken = (activeToken, tokens) => {
+    if (hasPropertyReference(activeToken)) {
+        return activeToken;
+    }
+    if (!activeToken) {
+        return undefined;
+    }
+    const index = tokens.findIndex((token) => token === activeToken);
+    if (index === -1) {
+        return undefined;
+    }
+    for (let i = index - 1; i >= 0; i--) {
+        const token = tokens[i];
+        if (token.tokenType.name === tokenVocabulary.Cell.name ||
+            token.tokenType.name === tokenVocabulary.TableColumnName.name ||
+            token.tokenType.name === tokenVocabulary.TableName.name) {
+            if (hasPropertyReference(token)) {
+                return token;
+            }
+        }
+    }
+    return undefined;
+};
+/**
+ * Get active table token
+ * @param position
+ * @param activeToken
+ * @param tokens
+ * @param view
+ * @param isEdge
+ * @returns
+ */
+export const getActiveTableToken = (position, activeToken, tokens, view, isEdge) => {
+    if (!activeToken)
+        return undefined;
+    let table = void 0;
+    // Get character before cursor - use tokenized content for consistency
+    const { state } = view;
+    const fullContent = state.doc.textContent;
+    // Map position back to the original content
+    // For now, use simple approach since position is within tokenized text
+    const previousCharacter = position > 0 && fullContent.length > position - 1
+        ? fullContent.charAt(position - 1)
+        : "";
+    const isFocusOutsideToken = position > activeToken.endColumn;
+    // Table1[Column]<--
+    if (isEdge && previousCharacter === "]") {
+        return undefined;
+    }
+    // Table[Column]   <--- token with spaces
+    if (activeToken.tokenType.name === tokenVocabulary.TableName.name &&
+        !isFocusOutsideToken) {
+        return activeToken;
+    }
+    // [  <--- Square with space
+    if (activeToken.tokenType.name === tokenVocabulary.OpenSquareParen.name &&
+        !isFocusOutsideToken) {
+        table = activeToken;
+    }
+    let i = tokens.findIndex((token) => token === activeToken);
+    while (i > 0) {
+        const token = tokens[i];
+        // User starts with [ or [Column
+        if (token.tokenType.name === tokenVocabulary.OpenSquareParen.name ||
+            token.tokenType.name === tokenVocabulary.TableColumnName.name) {
+            const previousToken = tokens[i - 1];
+            if (!previousToken ||
+                CELL_SUGGESTION_PREFIX.indexOf(previousToken.tokenType.name) !== -1) {
+                return token;
+            }
+        }
+        // Find tableName by going back from the
+        // current location
+        if ([
+            tokenVocabulary.Name.name,
+            tokenVocabulary.OpenSquareParen.name,
+            tokenVocabulary.CloseSquareParen.name,
+            tokenVocabulary.Colon.name,
+            tokenVocabulary.Column.name,
+        ].indexOf(token.tokenType.name) !== -1) {
+            i--;
+            continue;
+        }
+        // Exclude certain tokens that should not be inside
+        // a structured reference
+        if (CELL_SUGGESTION_SUFFIX.indexOf(token.tokenType.name) !== -1 ||
+            CELL_SUGGESTION_PREFIX.indexOf(token.tokenType.name) !== -1) {
+            return undefined;
+        }
+        // Found table
+        if (token.tokenType.name === tokenVocabulary.TableName.name) {
+            table = token;
+            break;
+        }
+        i--;
+    }
+    return table;
+};
+/**
+ * Get current parameter index that use is focused on
+ * @param curToken
+ * @param functionToken
+ * @param tokens
+ */
+export const getParameterIndex = (curToken, functionToken, tokens) => {
+    let startIndex = tokens.findIndex((token) => token === curToken);
+    const endIndex = tokens.findIndex((token) => token === functionToken);
+    let count = 0;
+    /* Skips nested functions */
+    let skip = 0;
+    // Fix for =SUMX2MY2({1, 2, 3}, {4, 5, 6}), Store indices we should skip
+    let replace = false;
+    const skipCommaIndices = [];
+    for (let i = tokens.length - 1; i >= 0; i--) {
+        const token = tokens[i];
+        if (token.image === "}") {
+            replace = true;
+        }
+        else if (token.image === "{") {
+            replace = false;
+        }
+        else {
+            if (replace) {
+                skipCommaIndices.push(i);
+            }
+        }
+    }
+    while (startIndex > endIndex) {
+        const token = tokens[startIndex];
+        if (token.image === ")") {
+            skip++;
+        }
+        else if (token.tokenType.name === "Comma" &&
+            skip === 0 &&
+            !(skipCommaIndices.indexOf(startIndex) !== -1)) {
+            count++;
+        }
+        if (token.tokenType.name === "Function") {
+            if (skip > 0)
+                skip--;
+        }
+        startIndex--;
+    }
+    return count;
+};
+export const getFunctionParameters = (input, functionToken) => {
+    if (!functionToken) {
+        return { parameters: [], ranges: [] };
+    }
+    const searchStart = functionToken.startColumn ?? 0;
+    const openIndex = input.indexOf("(", searchStart);
+    if (openIndex === -1) {
+        return { parameters: [], ranges: [] };
+    }
+    let depth = 0;
+    let closeIndex = -1;
+    for (let i = openIndex; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === "(")
+            depth++;
+        else if (ch === ")") {
+            depth--;
+            if (depth === 0) {
+                closeIndex = i;
+                break;
+            }
+        }
+    }
+    // If user hasn't typed the closing paren yet, use the end of the string
+    if (closeIndex === -1) {
+        closeIndex = input.length;
+    }
+    if (closeIndex <= openIndex) {
+        return { parameters: [], ranges: [] };
+    }
+    const argsSlice = input.slice(openIndex + 1, closeIndex);
+    const parameters = [];
+    const ranges = [];
+    let start = 0;
+    let brace = 0;
+    let bracket = 0;
+    let paren = 0;
+    let inSingle = false;
+    let inDouble = false;
+    const pushParam = (endIndex) => {
+        const raw = argsSlice.slice(start, endIndex);
+        const leading = raw.length - raw.trimStart().length;
+        const trailing = raw.length - raw.trimEnd().length;
+        const absoluteStart = openIndex + 1 + start + leading;
+        const absoluteEnd = openIndex + 1 + endIndex - trailing;
+        parameters.push(raw.trim());
+        ranges.push({ start: absoluteStart, end: absoluteEnd });
+    };
+    for (let i = 0; i <= argsSlice.length; i++) {
+        const ch = argsSlice[i];
+        if (i === argsSlice.length ||
+            (ch === "," &&
+                paren === 0 &&
+                brace === 0 &&
+                bracket === 0 &&
+                !inSingle &&
+                !inDouble)) {
+            pushParam(i);
+            start = i + 1;
+            continue;
+        }
+        if (ch === "'" && !inDouble) {
+            inSingle = !inSingle;
+            continue;
+        }
+        if (ch === '"' && !inSingle) {
+            inDouble = !inDouble;
+            continue;
+        }
+        if (inSingle || inDouble)
+            continue;
+        if (ch === "(")
+            paren++;
+        else if (ch === ")")
+            paren--;
+        else if (ch === "{")
+            brace++;
+        else if (ch === "}")
+            brace--;
+        else if (ch === "[")
+            bracket++;
+        else if (ch === "]")
+            bracket--;
+    }
+    return { parameters, ranges };
+};
+/**
+ * Get content and offset for tokenization, handling both single and multi-line scenarios
+ * @param state ProseMirror editor state
+ * @param cursorPos Current cursor position
+ * @returns Object with line content and offset within that content
+ */
+export const getTokenizationContent = (state, cursorPos) => {
+    try {
+        // Validate cursor position
+        if (cursorPos < 0 || cursorPos > state.doc.content.size) {
+            console.warn(`Invalid cursor position: ${cursorPos}, doc size: ${state.doc.content.size}`);
+            return {
+                line: state.doc.textContent || "",
+                offsetInLine: 0,
+            };
+        }
+        const $pos = state.doc.resolve(cursorPos);
+        // Strategy 1: For typical spreadsheet formulas, tokenize entire content
+        // This works best when content is a single formula that may span lines
+        const fullContent = state.doc.textContent;
+        if (fullContent.startsWith("=") || fullContent.length <= 1000) {
+            // This looks like a formula or is short enough to tokenize entirely
+            // Calculate position in the full text content
+            // Need to account for ProseMirror's document structure vs plain text
+            let textPosition = 0;
+            let found = false;
+            state.doc.descendants((node, pos) => {
+                if (found)
+                    return false;
+                if (node.isText) {
+                    if (pos <= cursorPos && cursorPos <= pos + node.nodeSize) {
+                        // Cursor is within this text node
+                        textPosition += cursorPos - pos;
+                        found = true;
+                        return false;
+                    }
+                    else if (pos + node.nodeSize < cursorPos) {
+                        // This text node is before cursor position
+                        textPosition += node.text?.length || 0;
+                    }
+                }
+                return !found;
+            });
+            return {
+                line: fullContent,
+                offsetInLine: Math.max(0, textPosition),
+            };
+        }
+        // Strategy 2: For non-formula content, use current line approach
+        // This works better for multi-line text that isn't a single formula
+        const parent = $pos.parent;
+        if (parent && parent.isTextblock) {
+            const lineStart = $pos.start($pos.depth);
+            const offsetInLine = Math.max(0, cursorPos - lineStart);
+            return {
+                line: parent.textContent || "",
+                offsetInLine: offsetInLine,
+            };
+        }
+        // Strategy 3: Fallback to full content with simple position mapping
+        return {
+            line: fullContent,
+            offsetInLine: Math.max(0, Math.min(cursorPos, fullContent.length)),
+        };
+    }
+    catch (error) {
+        console.warn("Error getting tokenization content:", error);
+        // Safe fallback
+        const safeContent = state.doc.textContent || "";
+        return {
+            line: safeContent,
+            offsetInLine: Math.max(0, Math.min(cursorPos, safeContent.length)),
+        };
+    }
+};
+/**
+ * Cleanup function token to remove parentheses
+ * @param text
+ */
+export const cleanFunctionToken = (text) => {
+    return text.replace(new RegExp(/\(|\)/, "gi"), "");
+};
+// Alternative approach using ProseMirror's built-in word detection:
+function getWordAtPosition(editorState, pos) {
+    const doc = editorState.doc;
+    const $pos = doc.resolve(pos);
+    // Use ProseMirror's word pattern matching
+    const wordRE = /\w+/g;
+    const textNode = $pos.parent;
+    const textContent = textNode.textContent;
+    const localPos = $pos.parentOffset;
+    let match;
+    let wordStart = null;
+    let wordEnd = null;
+    // Find all word matches and determine which one contains our position
+    while ((match = wordRE.exec(textContent)) !== null) {
+        const matchStart = match.index;
+        const matchEnd = match.index + match[0].length;
+        if (localPos >= matchStart && localPos <= matchEnd) {
+            wordStart = $pos.start() + matchStart;
+            wordEnd = $pos.start() + matchEnd;
+            break;
+        }
+    }
+    if (wordStart === null || wordEnd === null) {
+        return undefined;
+    }
+    const wordText = doc.textBetween(wordStart, wordEnd, " ");
+    return {
+        start: wordStart,
+        end: wordEnd,
+        text: wordText,
+    };
+}