@rowsncolumns/ui 15.0.38

package/dist/esm/editor-pm/schema.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from "prosemirror-model";
+export declare const schema: Schema<"text" | "line" | "mention" | "doc", "color" | "bold" | "fontFamily" | "fontSize" | "italic" | "strikethrough" | "underline" | "superscript" | "subscript">;
+//# sourceMappingURL=schema.d.ts.map

package/dist/esm/editor-pm/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../editor-pm/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,eAAO,MAAM,MAAM,oKAmLjB,CAAC"}

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

@@ -0,0 +1,179 @@
+import { Schema } from "prosemirror-model";
+export const schema = new Schema({
+    nodes: {
+        doc: {
+            content: "line*",
+        },
+        line: {
+            content: "inline*",
+            toDOM() {
+                return ["div", 0];
+            },
+            parseDOM: [{ tag: "div" }],
+        },
+        text: {
+            group: "inline",
+        },
+        mention: {
+            group: "inline",
+            inline: true,
+            atom: true,
+            selectable: true,
+            draggable: false,
+            attrs: { label: {}, value: {} },
+            parseDOM: [
+                {
+                    tag: "span[data-mention-value]",
+                    getAttrs(dom) {
+                        return {
+                            value: dom.getAttribute("data-mention-value"),
+                            label: dom.getAttribute("data-mention-label"),
+                        };
+                    },
+                },
+                {
+                    tag: "span[data-mention]",
+                    getAttrs(dom) {
+                        const text = dom.textContent || "";
+                        const match = text.match(/@(.+)/);
+                        return match
+                            ? {
+                                label: match[1],
+                                value: match[1],
+                            }
+                            : false;
+                    },
+                },
+            ],
+            toDOM(node) {
+                return [
+                    "span",
+                    {
+                        "data-mention-value": node.attrs.value,
+                        "data-mention-label": node.attrs.label,
+                    },
+                    `@[${node.attrs.label}](${node.attrs.value})`,
+                ];
+            },
+        },
+    },
+    marks: {
+        bold: {
+            toDOM() {
+                return ["strong", 0];
+            },
+            parseDOM: [
+                { tag: "strong" },
+                { tag: "b" },
+                {
+                    style: "font-weight",
+                    getAttrs: (value) => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null,
+                },
+            ],
+        },
+        italic: {
+            toDOM() {
+                return ["em", 0];
+            },
+            parseDOM: [
+                { tag: "em" },
+                { tag: "i" },
+                { style: "font-style=italic" },
+            ],
+        },
+        underline: {
+            toDOM() {
+                return ["u", 0];
+            },
+            parseDOM: [
+                { tag: "u" },
+                {
+                    style: "text-decoration",
+                    getAttrs: (value) => /^(underline)$/.test(String(value)) ? null : false,
+                },
+            ],
+        },
+        strikethrough: {
+            toDOM() {
+                return ["s", 0];
+            },
+            parseDOM: [
+                { tag: "s" },
+                { tag: "del" },
+                { tag: "strike" },
+                {
+                    style: "text-decoration",
+                    getAttrs: (value) => /^(line-through)$/.test(String(value)) ? null : false,
+                },
+            ],
+        },
+        // Superscript / subscript are mutually exclusive (a glyph can't be
+        // both), so each mark excludes the other in addition to itself —
+        // note `excludes` REPLACES ProseMirror's default self-exclusion,
+        // which is why the mark's own name is listed too.
+        superscript: {
+            excludes: "superscript subscript",
+            toDOM() {
+                return ["sup", 0];
+            },
+            parseDOM: [{ tag: "sup" }, { style: "vertical-align=super" }],
+        },
+        subscript: {
+            excludes: "subscript superscript",
+            toDOM() {
+                return ["sub", 0];
+            },
+            parseDOM: [{ tag: "sub" }, { style: "vertical-align=sub" }],
+        },
+        color: {
+            attrs: { color: {} },
+            toDOM(mark) {
+                return ["span", { style: `color: ${mark.attrs.color}` }, 0];
+            },
+            parseDOM: [
+                {
+                    tag: "span[style*=color]",
+                    getAttrs(dom) {
+                        const style = dom.getAttribute("style");
+                        const match = style.match(/color:\s*([^;]+)/);
+                        return match ? { color: match[1] } : false;
+                    },
+                },
+            ],
+        },
+        // Per-run font size, in points (the `TextFormat.fontSize` unit). Carried
+        // as a mark so xlsx-imported size runs survive an edit and so the toolbar
+        // font-size control can format a selection inside the cell editor.
+        fontSize: {
+            attrs: { size: {} },
+            toDOM(mark) {
+                return ["span", { style: `font-size: ${mark.attrs.size}pt` }, 0];
+            },
+            parseDOM: [
+                {
+                    style: "font-size",
+                    getAttrs: (value) => {
+                        const match = /^([\d.]+)pt$/.exec(String(value).trim());
+                        return match ? { size: Number(match[1]) } : false;
+                    },
+                },
+            ],
+        },
+        // Per-run font family (`TextFormat.fontFamily`).
+        fontFamily: {
+            attrs: { family: {} },
+            toDOM(mark) {
+                return ["span", { style: `font-family: ${mark.attrs.family}` }, 0];
+            },
+            parseDOM: [
+                {
+                    style: "font-family",
+                    getAttrs: (value) => {
+                        const family = String(value).replace(/["']/g, "").trim();
+                        return family ? { family } : false;
+                    },
+                },
+            ],
+        },
+    },
+});

package/dist/esm/editor-pm/types.d.ts

@@ -0,0 +1,8 @@
+export type { TextFormatRun, Mention } from "@rowsncolumns/common-types";
+export type OptionItem = {
+    title: string;
+    value?: string;
+    category?: OptionCategory;
+};
+export type OptionCategory = "table" | "function" | "column" | "namedrange" | "thisrow" | "specialitem" | "property" | "parameter";
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/editor-pm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../editor-pm/types.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAEzE,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,UAAU,GACV,QAAQ,GACR,YAAY,GACZ,SAAS,GACT,aAAa,GACb,UAAU,GACV,WAAW,CAAC"}

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

@@ -0,0 +1 @@
+export {};

package/dist/esm/editor-pm/unfocused-selection-plugin.d.ts

@@ -0,0 +1,25 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+/**
+ * Plugin state: `true` while the editor DOM is blurred.
+ */
+export declare const unfocusedSelectionPluginKey: PluginKey<boolean>;
+export declare const UNFOCUSED_SELECTION_CLASS = "rnc-pm-unfocused-selection";
+/**
+ * Keeps the user's text selection visibly painted while the editor does not
+ * own DOM focus.
+ *
+ * Browsers only paint the native selection of a contenteditable while it is
+ * focused, so interacting with a control that must take focus (the toolbar's
+ * font-size input, a dropdown search field, a color picker) makes the
+ * selection *appear* to vanish even though ProseMirror's state still holds
+ * it. This plugin mirrors that kept selection as an inline decoration while
+ * the view is blurred and removes it as soon as focus returns — the standard
+ * "fake selection" approach rich-text editors use for toolbar interop.
+ *
+ * The decoration uses the `Highlight` CSS system color so it matches the
+ * platform's native selection paint without any stylesheet wiring; the
+ * `rnc-pm-unfocused-selection` class is attached for hosts that want to
+ * restyle it.
+ */
+export declare function createUnfocusedSelectionPlugin(): Plugin<boolean>;
+//# sourceMappingURL=unfocused-selection-plugin.d.ts.map

package/dist/esm/editor-pm/unfocused-selection-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unfocused-selection-plugin.d.ts","sourceRoot":"","sources":["../../../editor-pm/unfocused-selection-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGtD;;GAEG;AACH,eAAO,MAAM,2BAA2B,oBAEvC,CAAC;AAEF,eAAO,MAAM,yBAAyB,+BAA+B,CAAC;AAEtE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,8BAA8B,oBA0C7C"}

package/dist/esm/editor-pm/unfocused-selection-plugin.js

@@ -0,0 +1,61 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+import { Decoration, DecorationSet } from "prosemirror-view";
+/**
+ * Plugin state: `true` while the editor DOM is blurred.
+ */
+export const unfocusedSelectionPluginKey = new PluginKey("unfocusedSelection");
+export const UNFOCUSED_SELECTION_CLASS = "rnc-pm-unfocused-selection";
+/**
+ * Keeps the user's text selection visibly painted while the editor does not
+ * own DOM focus.
+ *
+ * Browsers only paint the native selection of a contenteditable while it is
+ * focused, so interacting with a control that must take focus (the toolbar's
+ * font-size input, a dropdown search field, a color picker) makes the
+ * selection *appear* to vanish even though ProseMirror's state still holds
+ * it. This plugin mirrors that kept selection as an inline decoration while
+ * the view is blurred and removes it as soon as focus returns — the standard
+ * "fake selection" approach rich-text editors use for toolbar interop.
+ *
+ * The decoration uses the `Highlight` CSS system color so it matches the
+ * platform's native selection paint without any stylesheet wiring; the
+ * `rnc-pm-unfocused-selection` class is attached for hosts that want to
+ * restyle it.
+ */
+export function createUnfocusedSelectionPlugin() {
+    return new Plugin({
+        key: unfocusedSelectionPluginKey,
+        state: {
+            init: () => false,
+            apply(tr, blurred) {
+                const meta = tr.getMeta(unfocusedSelectionPluginKey);
+                return meta === undefined ? blurred : meta;
+            },
+        },
+        props: {
+            handleDOMEvents: {
+                blur(view) {
+                    view.dispatch(view.state.tr.setMeta(unfocusedSelectionPluginKey, true));
+                    return false;
+                },
+                focus(view) {
+                    view.dispatch(view.state.tr.setMeta(unfocusedSelectionPluginKey, false));
+                    return false;
+                },
+            },
+            decorations(state) {
+                const blurred = unfocusedSelectionPluginKey.getState(state);
+                const { from, to, empty } = state.selection;
+                if (!blurred || empty) {
+                    return null;
+                }
+                return DecorationSet.create(state.doc, [
+                    Decoration.inline(from, to, {
+                        class: UNFOCUSED_SELECTION_CLASS,
+                        style: "background-color: Highlight;",
+                    }),
+                ]);
+            },
+        },
+    });
+}

package/dist/esm/editor-pm/use-dropdown-change-pm.d.ts

@@ -0,0 +1,24 @@
+import type { ParsedToken } from "@rowsncolumns/calculator";
+import { EditorView } from "prosemirror-view";
+import { OptionItem, TextFormatRun } from "./types";
+type InputProps = {
+    itemToString(value: OptionItem): string;
+    formulaMode?: boolean;
+    getView(): EditorView | null;
+    onSubmit?(value: string, textFormatRuns?: TextFormatRun[] | null): void;
+    suggestionToken: ParsedToken | undefined;
+    activeToken: ParsedToken | undefined;
+    propertyToken?: ParsedToken | undefined;
+    parameterRange?: {
+        start: number;
+        end: number;
+    } | undefined;
+    previousToken?: ParsedToken | undefined;
+};
+export declare const getUnterminatedStringRange: (token: ParsedToken | undefined, docSize: number, fallbackEnd: number) => {
+    from: number;
+    to: number;
+} | null;
+export declare const useDropdownChangePM: ({ itemToString, formulaMode, getView, onSubmit, suggestionToken, activeToken, propertyToken, parameterRange, previousToken, }: InputProps) => (item: OptionItem) => void;
+export {};
+//# sourceMappingURL=use-dropdown-change-pm.d.ts.map

package/dist/esm/editor-pm/use-dropdown-change-pm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-dropdown-change-pm.d.ts","sourceRoot":"","sources":["../../../editor-pm/use-dropdown-change-pm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGpD,KAAK,UAAU,GAAG;IAChB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAAC;IACxC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,OAAO,IAAI,UAAU,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,aAAa,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;IACxE,eAAe,EAAE,WAAW,GAAG,SAAS,CAAC;IACzC,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC;IACrC,aAAa,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IACxC,cAAc,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;IAC5D,aAAa,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;CACzC,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,OAAO,WAAW,GAAG,SAAS,EAC9B,SAAS,MAAM,EACf,aAAa,MAAM;;;QAkBpB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,+HAUjC,UAAU,YAEF,UAAU,SAsJpB,CAAC"}

package/dist/esm/editor-pm/use-dropdown-change-pm.js

@@ -0,0 +1,137 @@
+import { useCallback } from "react";
+import { TextSelection } from "prosemirror-state";
+import { tokenVocabulary } from "@rowsncolumns/fast-formula-parser";
+import { extractTextFormatRuns, getPropertyStartIndex } from "./helpers";
+export const getUnterminatedStringRange = (token, docSize, fallbackEnd) => {
+    if (!token ||
+        token.tokenType?.name !== tokenVocabulary.UnterminatedStringStart.name) {
+        return null;
+    }
+    const tokenLength = token.image?.length ?? 0;
+    const fallbackStart = fallbackEnd - tokenLength;
+    const startOffset = token.startOffset !== undefined ? token.startOffset : fallbackStart - 1;
+    const start = Math.max(0, Math.min(startOffset + 1, docSize));
+    const end = Math.max(start, Math.min(start + tokenLength, docSize));
+    if (end <= start) {
+        return null;
+    }
+    return { from: start, to: end };
+};
+export const useDropdownChangePM = ({ itemToString, formulaMode, getView, onSubmit, suggestionToken, activeToken, propertyToken, parameterRange, previousToken, }) => {
+    return useCallback((item) => {
+        const category = item.category;
+        const value = itemToString(item);
+        const view = getView();
+        if (formulaMode && view) {
+            const { state } = view;
+            const { tr } = state;
+            const { selection } = state;
+            let insertPos = selection.from;
+            if (category === "parameter" && parameterRange) {
+                const from = Math.max(0, Math.min(parameterRange.start, state.doc.content.size));
+                const to = Math.max(from, Math.min(parameterRange.end, state.doc.content.size));
+                tr.delete(from, to);
+                tr.insertText(value, from);
+                const newCursorPos = from + value.length;
+                tr.setSelection(TextSelection.near(tr.doc.resolve(newCursorPos)));
+                view.dispatch(tr);
+                view.focus();
+                return;
+            }
+            const deleteUnterminatedToken = (tokenToDelete, fallbackEnd) => {
+                const range = getUnterminatedStringRange(tokenToDelete, state.doc.content.size, fallbackEnd ?? insertPos);
+                if (range) {
+                    tr.delete(range.from, range.to);
+                    insertPos = range.from;
+                }
+            };
+            // // If we have a suggestion token, delete it and update insert position
+            if (suggestionToken) {
+                let from = suggestionToken.startOffset + 1;
+                let to = suggestionToken.startOffset +
+                    (suggestionToken.image?.length ?? 0) +
+                    1;
+                if (category === "property") {
+                    const baseToken = propertyToken ||
+                        suggestionToken.basePropertyToken ||
+                        suggestionToken;
+                    if (baseToken?.image) {
+                        const dotIndex = getPropertyStartIndex(baseToken);
+                        if (dotIndex !== -1) {
+                            const baseStart = (baseToken.startOffset ?? 0) + 1;
+                            from = baseStart + dotIndex;
+                            const tokenEnd = baseStart + baseToken.image.length;
+                            to = tokenEnd;
+                        }
+                    }
+                }
+                let handled = false;
+                if (from <= to && to <= state.doc.content.size) {
+                    tr.delete(from, to);
+                    insertPos = from;
+                    handled = true;
+                }
+                if (!handled) {
+                    deleteUnterminatedToken(suggestionToken);
+                }
+            }
+            deleteUnterminatedToken(previousToken, insertPos);
+            let textToInsert = "";
+            switch (category) {
+                case "table": {
+                    const prevChar = insertPos > 0
+                        ? state.doc.textBetween(insertPos - 1, insertPos)
+                        : "";
+                    const nextChar = state.doc.textBetween(insertPos, insertPos + 1);
+                    textToInsert = value + "[";
+                    break;
+                }
+                case "column": {
+                    const prevChar = insertPos > 0
+                        ? state.doc.textBetween(insertPos - 1, insertPos)
+                        : "";
+                    const nextChar = state.doc.textBetween(insertPos, insertPos + 1);
+                    const prefix = prevChar === "[" || prevChar === "@" ? "" : "[";
+                    const suffix = nextChar === "]" ? "" : "]";
+                    textToInsert = prefix + value + suffix;
+                    break;
+                }
+                case "thisrow":
+                    textToInsert = "@";
+                    break;
+                case "namedrange":
+                case "specialitem":
+                case "parameter":
+                    textToInsert = value;
+                    break;
+                case "property":
+                    textToInsert = "." + value;
+                    break;
+                case "function":
+                default:
+                    textToInsert = value + "(";
+                    break;
+            }
+            // Insert the text and move cursor to the end
+            tr.insertText(textToInsert, insertPos);
+            const newCursorPos = insertPos + textToInsert.length;
+            tr.setSelection(TextSelection.near(tr.doc.resolve(newCursorPos)));
+            view.dispatch(tr);
+            view.focus();
+        }
+        else {
+            const textFormatRuns = extractTextFormatRuns(view?.state.doc);
+            onSubmit?.(value, textFormatRuns);
+        }
+    }, [
+        onSubmit,
+        formulaMode,
+        getView,
+        itemToString,
+        suggestionToken,
+        activeToken,
+        propertyToken,
+        parameterRange,
+        previousToken,
+    ]);
+};

package/dist/esm/editor-pm/use-editor-change-pm.d.ts

@@ -0,0 +1,29 @@
+import { type ParsedToken } from "@rowsncolumns/calculator";
+import { EditorState } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import type { ProseMirrorEditorProps } from "./prosemirror-editor";
+import { TextFormatRun } from "./types";
+type UseEditorOnChangePMProps = {
+    onChange(value: string, textFormatRuns?: TextFormatRun[] | null): void;
+    getView(): EditorView | null;
+    isActive?: boolean;
+    enableContinuousSelection?: boolean;
+    onChangeCursor(position: number | undefined): void;
+    onChangeActiveToken(token: ParsedToken | undefined): void;
+    tokenizer(value: string): ParsedToken[];
+    onFormulaStateChange: ProseMirrorEditorProps["onFormulaStateChange"];
+    onSuggestionTokenChange(token: ParsedToken | undefined): void;
+    onTableTokenChange(token: ParsedToken | undefined): void;
+    onChangeFunctionToken(token: ParsedToken | undefined): void;
+    onChangeParameterIndex(index: number): void;
+    onChangeIsEdgeOfCell(isEdgeOfCell: boolean): void;
+    onCellPropertyTokenChange(token: ParsedToken | undefined): void;
+    onChangeFunctionParameters?(params: string[], ranges: {
+        start: number;
+        end: number;
+    }[]): void;
+    onChangePreviousToken(token: ParsedToken | undefined): void;
+};
+export declare const useEditorOnChangePM: ({ onChange, getView, isActive, enableContinuousSelection, tokenizer, onChangeCursor, onChangeActiveToken, onFormulaStateChange, onSuggestionTokenChange, onTableTokenChange, onChangeFunctionToken, onChangeParameterIndex, onCellPropertyTokenChange, onChangeFunctionParameters, onChangeIsEdgeOfCell, onChangePreviousToken, }: UseEditorOnChangePMProps) => (newState: EditorState) => void;
+export {};
+//# sourceMappingURL=use-editor-change-pm.d.ts.map

package/dist/esm/editor-pm/use-editor-change-pm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-editor-change-pm.d.ts","sourceRoot":"","sources":["../../../editor-pm/use-editor-change-pm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG7E,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAuBnE,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGxC,KAAK,wBAAwB,GAAG;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,aAAa,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;IACvE,OAAO,IAAI,UAAU,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACnD,mBAAmB,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAAC;IAC1D,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,EAAE,CAAC;IACxC,oBAAoB,EAAE,sBAAsB,CAAC,sBAAsB,CAAC,CAAC;IACrE,uBAAuB,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAAC;IAC9D,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAAC;IACzD,qBAAqB,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAAC;IAC5D,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,oBAAoB,CAAC,YAAY,EAAE,OAAO,GAAG,IAAI,CAAC;IAClD,yBAAyB,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAAC;IAChE,0BAA0B,CAAC,CACzB,MAAM,EAAE,MAAM,EAAE,EAChB,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,GACvC,IAAI,CAAC;IACR,qBAAqB,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAAC;CAC7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,mUAiBjC,wBAAwB,gBAWV,WAAW,SA6M3B,CAAC"}

package/dist/esm/editor-pm/use-editor-change-pm.js

@@ -0,0 +1,152 @@
+import { tokenVocabulary } from "@rowsncolumns/calculator";
+import { isAFormula } from "@rowsncolumns/utils";
+import { useCallback, useEffect, useRef } from "react";
+import { enableCellSelection, extractTextFormatRuns, getActiveFunctionToken, getActiveSelectionIndex, getActiveSuggestionToken, getActiveTableToken, getActiveToken, getCursorPosition, getFunctionParameters, getParameterIndex, getTokenizationContent, getPreviousToken, hasPropertyReference, isCellToken, isNamedRangeToken, isTableColumnToken, isTableNameToken, resolveCellPropertyToken, serializeEditorValue, } from "./helpers";
+import { useCallbackRef } from "@rowsncolumns/grid";
+import { CELL_SUGGESTION_PREFIX } from "../editor/constants";
+export const useEditorOnChangePM = ({ onChange, getView, isActive, enableContinuousSelection, tokenizer, onChangeCursor, onChangeActiveToken, onFormulaStateChange, onSuggestionTokenChange, onTableTokenChange, onChangeFunctionToken, onChangeParameterIndex, onCellPropertyTokenChange, onChangeFunctionParameters, onChangeIsEdgeOfCell, onChangePreviousToken, }) => {
+    const lastSeenCursorTokenRef = useRef(undefined);
+    useEffect(() => {
+        if (!isActive) {
+            lastSeenCursorTokenRef.current = undefined;
+        }
+    }, [isActive]);
+    return useCallbackRef(useCallback((newState) => {
+        const newValue = serializeEditorValue(newState.doc);
+        const isFormula = isAFormula(newValue);
+        const textFormatRuns = isFormula
+            ? undefined
+            : extractTextFormatRuns(newState.doc);
+        // Callback
+        onChange(newValue, textFormatRuns);
+        // Formula mode
+        const view = getView();
+        // Set cursor tokens
+        if (isFormula && isActive && view) {
+            const cursorPos = getCursorPosition(newState);
+            if (cursorPos === undefined) {
+                lastSeenCursorTokenRef.current = undefined;
+                onChangeCursor(undefined);
+                return;
+            }
+            // Get content for tokenization - handle both single and multi-line scenarios
+            const { line, offsetInLine } = getTokenizationContent(newState, cursorPos);
+            const tokens = tokenizer(line);
+            const activeToken = getActiveToken(offsetInLine, tokens);
+            const previousToken = getPreviousToken(offsetInLine, tokens);
+            const isEdge = activeToken?.endColumn === offsetInLine;
+            const isCell = activeToken
+                ? isCellToken(activeToken) ||
+                    isTableColumnToken(activeToken) ||
+                    isTableNameToken(activeToken)
+                : false;
+            const isNamedRange = activeToken
+                ? isNamedRangeToken(activeToken)
+                : false;
+            const isEdgeOfCell = isEdge &&
+                ((isCell && !hasPropertyReference(activeToken)) || isNamedRange);
+            let canSelectCells = Boolean(enableCellSelection(offsetInLine, cursorPos, tokens));
+            const selectionIndex = getActiveSelectionIndex(activeToken);
+            const suggestionToken = getActiveSuggestionToken(offsetInLine, activeToken, view);
+            const tableToken = getActiveTableToken(offsetInLine, activeToken, tokens, view, isEdge);
+            const tokenForFunction = activeToken ?? previousToken;
+            const functionToken = getActiveFunctionToken(tokenForFunction, tokens);
+            // Check for cell property token - we want to show suggestions when user types "A1."
+            let cellPropertyToken = resolveCellPropertyToken(activeToken, tokens);
+            if (!cellPropertyToken && suggestionToken) {
+                const basePropertyToken = suggestionToken.basePropertyToken;
+                if (basePropertyToken) {
+                    cellPropertyToken = basePropertyToken;
+                }
+            }
+            const isPropertyContext = Boolean(cellPropertyToken);
+            if (isPropertyContext) {
+                canSelectCells = false;
+            }
+            if (canSelectCells) {
+                lastSeenCursorTokenRef.current = cursorPos;
+            }
+            const charBeforeCursor = offsetInLine > 0 ? line[offsetInLine - 1] : "";
+            const isSpaceTerminator = charBeforeCursor === " " &&
+                !CELL_SUGGESTION_PREFIX.includes(previousToken?.tokenType?.name ?? "");
+            if (isSpaceTerminator) {
+                lastSeenCursorTokenRef.current = undefined;
+            }
+            const lastSeenCursorPos = lastSeenCursorTokenRef.current;
+            const isLiteralToken = activeToken?.tokenType?.name === tokenVocabulary.String.name ||
+                activeToken?.tokenType?.name ===
+                    tokenVocabulary.UnterminatedStringStart.name ||
+                activeToken?.tokenType?.name === tokenVocabulary.Number.name ||
+                activeToken?.tokenType?.name === tokenVocabulary.Boolean.name;
+            const isContinuation = enableContinuousSelection
+                ? canSelectCells || isEdgeOfCell
+                : !isPropertyContext &&
+                    !isLiteralToken &&
+                    lastSeenCursorPos !== undefined &&
+                    cursorPos >= lastSeenCursorPos;
+            if (isLiteralToken || (!canSelectCells && !isContinuation)) {
+                lastSeenCursorTokenRef.current = undefined;
+            }
+            // Get function parameters
+            const parameterIndex = getParameterIndex(tokenForFunction, functionToken, tokens);
+            const { parameters, ranges } = getFunctionParameters(line, functionToken);
+            // Cursor position to show cell suggestion
+            onChangeCursor(canSelectCells ? cursorPos : undefined);
+            // Active token
+            onChangeActiveToken(activeToken);
+            onChangePreviousToken(previousToken);
+            onSuggestionTokenChange?.(suggestionToken);
+            // Table token change
+            onTableTokenChange?.(tableToken);
+            // Function token change
+            onChangeFunctionToken?.(functionToken);
+            // Cell property token change
+            onCellPropertyTokenChange?.(cellPropertyToken);
+            // On parameter index change
+            onChangeParameterIndex?.(parameterIndex);
+            onChangeFunctionParameters?.(parameters, ranges);
+            onChangeIsEdgeOfCell(isEdgeOfCell);
+            /**
+             * Users are able to select cells
+             * 1. When canUserSelect = true
+             */
+            const finalCanSelectCells = !isPropertyContext && (canSelectCells || isContinuation);
+            const selectionMode = isPropertyContext || !canSelectCells ? "modify" : "append";
+            // Callback to update
+            onFormulaStateChange?.(finalCanSelectCells, selectionMode, selectionIndex);
+        }
+        else {
+            lastSeenCursorTokenRef.current = undefined;
+            // Function token change
+            onChangeFunctionToken?.(undefined);
+            onChangeFunctionParameters?.([], []);
+            // Set suggestion token
+            onSuggestionTokenChange({
+                image: newValue,
+                startColumn: 0,
+                startOffset: 0,
+                endColumn: 0,
+                endOffset: 0,
+                endLine: 0,
+                tokenType: { name: "Suggestion" },
+                tokenTypeIdx: 0,
+            });
+        }
+    }, [
+        onChange,
+        getView,
+        isActive,
+        enableContinuousSelection,
+        tokenizer,
+        onFormulaStateChange,
+        onChangeActiveToken,
+        onSuggestionTokenChange,
+        onChangeIsEdgeOfCell,
+        onChangeCursor,
+        onTableTokenChange,
+        onChangeFunctionToken,
+        onChangeParameterIndex,
+        onCellPropertyTokenChange,
+        onChangeFunctionParameters,
+    ]));
+};

package/dist/esm/editor-pm/use-editor-decorator-pm.d.ts

@@ -0,0 +1,17 @@
+import type { ParsedToken } from "@rowsncolumns/calculator";
+import { EditorState } from "prosemirror-state";
+import { DecorationSet } from "prosemirror-view";
+import { type LeafDecorator } from "./helpers";
+export type DecoratorRange = LeafDecorator & {
+    from: number;
+    to: number;
+};
+type UseDecoratorPMProps = {
+    cursorPosition: number | undefined;
+    formulaMode?: boolean;
+    isActive?: boolean;
+    tokenizer(value: string): ParsedToken[];
+};
+export declare const useEditorDecoratorPM: ({ cursorPosition, formulaMode, tokenizer, isActive, }: UseDecoratorPMProps) => (state: EditorState) => DecorationSet;
+export {};
+//# sourceMappingURL=use-editor-decorator-pm.d.ts.map