@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/prosemirror/plugins/index.js

@@ -0,0 +1,3 @@
+import { createDocumentStylesPlugin, documentStylesKey, getDocumentStyleResolver } from "./documentStyles.js";
+import { createSelectionTrackerPlugin, extractSelectionContext, getSelectionContext, selectionTrackerKey } from "./selectionTracker.js";
+export { createDocumentStylesPlugin, createSelectionTrackerPlugin, documentStylesKey, extractSelectionContext, getDocumentStyleResolver, getSelectionContext, selectionTrackerKey };

package/dist/prosemirror/plugins/pmTextScan.d.ts

@@ -0,0 +1,19 @@
+import { Node } from "prosemirror-model";
+
+//#region src/prosemirror/plugins/pmTextScan.d.ts
+type TextChunk = {
+  text: string; /** PM doc position where this chunk's first char lives. */
+  start: number;
+};
+/**
+ * Collect every block-level node's text content as an array of
+ * chunks (one per PM text node), grouped per block. Join a block's
+ * chunk texts to scan it as a single string.
+ */
+declare const collectBlockChunks: (doc: Node) => TextChunk[][];
+/** Map a joined-string offset back to its PM doc position. */
+declare const offsetToDocPos: (chunks: TextChunk[], offset: number) => number;
+/** Join a block's chunks into the single string callers scan. */
+declare const joinChunks: (chunks: TextChunk[]) => string;
+//#endregion
+export { TextChunk, collectBlockChunks, joinChunks, offsetToDocPos };

package/dist/prosemirror/plugins/pmTextScan.js

@@ -0,0 +1,39 @@
+//#region src/prosemirror/plugins/pmTextScan.ts
+/**
+* Collect every block-level node's text content as an array of
+* chunks (one per PM text node), grouped per block. Join a block's
+* chunk texts to scan it as a single string.
+*/
+const collectBlockChunks = (doc) => {
+	const blocks = [];
+	doc.descendants((node, pos) => {
+		if (node.isTextblock) {
+			const chunks = [];
+			node.descendants((child, offset) => {
+				if (child.isText && child.text !== void 0) chunks.push({
+					text: child.text,
+					start: pos + 1 + offset
+				});
+				return true;
+			});
+			if (chunks.length > 0) blocks.push(chunks);
+			return false;
+		}
+		return true;
+	});
+	return blocks;
+};
+/** Map a joined-string offset back to its PM doc position. */
+const offsetToDocPos = (chunks, offset) => {
+	let consumed = 0;
+	for (const chunk of chunks) {
+		if (offset <= consumed + chunk.text.length) return chunk.start + (offset - consumed);
+		consumed += chunk.text.length;
+	}
+	const last = chunks.at(-1);
+	return last ? last.start + last.text.length : 0;
+};
+/** Join a block's chunks into the single string callers scan. */
+const joinChunks = (chunks) => chunks.map((c) => c.text).join("");
+//#endregion
+export { collectBlockChunks, joinChunks, offsetToDocPos };

package/dist/prosemirror/plugins/selectionTracker.d.ts

@@ -0,0 +1,43 @@
+import { document_d_exports } from "../../types/document.js";
+import { EditorState, Plugin, PluginKey } from "prosemirror-state";
+
+//#region src/prosemirror/plugins/selectionTracker.d.ts
+/**
+ * Selection context for toolbar state
+ */
+type SelectionContext = {
+  /** Whether there's a non-collapsed selection */hasSelection: boolean; /** Whether selection spans multiple paragraphs */
+  isMultiParagraph: boolean; /** Current text formatting at cursor/selection */
+  textFormatting: document_d_exports.TextFormatting; /** Current paragraph formatting */
+  paragraphFormatting: document_d_exports.ParagraphFormatting; /** Start paragraph index */
+  startParagraphIndex: number; /** End paragraph index */
+  endParagraphIndex: number; /** Whether cursor is in a list */
+  inList: boolean; /** List type if in list */
+  listType?: "bullet" | "numbered"; /** List level (0-8) */
+  listLevel?: number; /** Active comment IDs at cursor position */
+  activeCommentIds: number[]; /** Whether cursor is inside a tracked insertion */
+  inInsertion: boolean; /** Whether cursor is inside a tracked deletion */
+  inDeletion: boolean;
+};
+/**
+ * Plugin key for accessing selection tracker state
+ */
+declare const selectionTrackerKey: PluginKey<SelectionContext>;
+/**
+ * Callback type for selection changes
+ */
+type SelectionChangeCallback = (context: SelectionContext) => void;
+/**
+ * Extract selection context from editor state
+ */
+declare function extractSelectionContext(state: EditorState): SelectionContext;
+/**
+ * Create selection tracker plugin
+ */
+declare function createSelectionTrackerPlugin(onSelectionChange?: SelectionChangeCallback): Plugin;
+/**
+ * Get current selection context from editor state
+ */
+declare function getSelectionContext(state: EditorState): SelectionContext | null;
+//#endregion
+export { SelectionChangeCallback, SelectionContext, createSelectionTrackerPlugin, extractSelectionContext, getSelectionContext, selectionTrackerKey };

package/dist/prosemirror/plugins/selectionTracker.js

@@ -0,0 +1,179 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+//#region src/prosemirror/plugins/selectionTracker.ts
+/**
+* Selection Tracker Plugin
+*
+* Tracks selection changes and emits events for toolbar state updates.
+* Provides the current selection context including:
+* - Text formatting at cursor/selection
+* - Paragraph formatting
+* - Selection range information
+*/
+/**
+* Plugin key for accessing selection tracker state
+*/
+const selectionTrackerKey = new PluginKey("selectionTracker");
+/**
+* Extract selection context from editor state
+*/
+function extractSelectionContext(state) {
+	const { selection, doc } = state;
+	const { from, to, empty } = selection;
+	const $from = doc.resolve(from);
+	let startParagraphIndex = 0;
+	let endParagraphIndex = 0;
+	doc.forEach((_node, offset, index) => {
+		if (offset > to) return;
+		if (offset <= from) startParagraphIndex = index;
+		if (offset <= to) endParagraphIndex = index;
+	});
+	const textFormatting = extractTextFormatting(state);
+	const paragraph = $from.parent;
+	const paragraphFormatting = {};
+	if (paragraph.type.name === "paragraph") {
+		if (paragraph.attrs["alignment"]) paragraphFormatting.alignment = paragraph.attrs["alignment"];
+		if (paragraph.attrs["lineSpacing"]) {
+			paragraphFormatting.lineSpacing = paragraph.attrs["lineSpacing"];
+			paragraphFormatting.lineSpacingRule = paragraph.attrs["lineSpacingRule"];
+		}
+		if (paragraph.attrs["indentLeft"]) paragraphFormatting.indentLeft = paragraph.attrs["indentLeft"];
+		if (paragraph.attrs["indentRight"]) paragraphFormatting.indentRight = paragraph.attrs["indentRight"];
+		if (paragraph.attrs["indentFirstLine"]) paragraphFormatting.indentFirstLine = paragraph.attrs["indentFirstLine"];
+		if (paragraph.attrs["hangingIndent"]) paragraphFormatting.hangingIndent = paragraph.attrs["hangingIndent"];
+		if (paragraph.attrs["tabs"]) paragraphFormatting.tabs = paragraph.attrs["tabs"];
+		if (paragraph.attrs["numPr"]) paragraphFormatting.numPr = paragraph.attrs["numPr"];
+		if (paragraph.attrs["styleId"]) paragraphFormatting.styleId = paragraph.attrs["styleId"];
+	}
+	const numPr = paragraph.attrs["numPr"];
+	const inList = !!numPr?.numId;
+	let listType;
+	if (numPr?.numId === 1) listType = "bullet";
+	else if (numPr?.numId) listType = "numbered";
+	const listLevel = numPr?.ilvl;
+	const allMarks = state.storedMarks || (empty ? $from.marks() : []);
+	const activeCommentIds = [];
+	let inInsertion = false;
+	let inDeletion = false;
+	for (const mark of allMarks) {
+		if (mark.type.name === "comment" && mark.attrs["commentId"]) activeCommentIds.push(mark.attrs["commentId"]);
+		if (mark.type.name === "insertion") inInsertion = true;
+		if (mark.type.name === "deletion") inDeletion = true;
+	}
+	return {
+		hasSelection: !empty,
+		isMultiParagraph: startParagraphIndex !== endParagraphIndex,
+		textFormatting,
+		paragraphFormatting,
+		startParagraphIndex,
+		endParagraphIndex,
+		inList,
+		...listType !== void 0 ? { listType } : {},
+		...listLevel !== void 0 ? { listLevel } : {},
+		activeCommentIds,
+		inInsertion,
+		inDeletion
+	};
+}
+/**
+* Extract text formatting from current selection/cursor marks
+*/
+function extractTextFormatting(state) {
+	const { selection } = state;
+	const { empty, $from } = selection;
+	const marks = state.storedMarks || (empty ? $from.marks() : []);
+	const formatting = {};
+	for (const mark of marks) switch (mark.type.name) {
+		case "bold":
+			formatting.bold = true;
+			break;
+		case "italic":
+			formatting.italic = true;
+			break;
+		case "underline":
+			formatting.underline = {
+				style: mark.attrs["style"] || "single",
+				color: mark.attrs["color"]
+			};
+			break;
+		case "strike":
+			if (mark.attrs["double"]) formatting.doubleStrike = true;
+			else formatting.strike = true;
+			break;
+		case "textColor":
+			formatting.color = {
+				rgb: mark.attrs["rgb"],
+				themeColor: mark.attrs["themeColor"],
+				themeTint: mark.attrs["themeTint"],
+				themeShade: mark.attrs["themeShade"]
+			};
+			break;
+		case "highlight":
+			formatting.highlight = mark.attrs["color"];
+			break;
+		case "fontSize":
+			formatting.fontSize = mark.attrs["size"];
+			break;
+		case "fontFamily":
+			formatting.fontFamily = {
+				ascii: mark.attrs["ascii"],
+				hAnsi: mark.attrs["hAnsi"],
+				asciiTheme: mark.attrs["asciiTheme"]
+			};
+			break;
+		case "superscript":
+			formatting.vertAlign = "superscript";
+			break;
+		case "subscript":
+			formatting.vertAlign = "subscript";
+			break;
+		default: break;
+	}
+	return formatting;
+}
+/**
+* Create selection tracker plugin
+*/
+function createSelectionTrackerPlugin(onSelectionChange) {
+	return new Plugin({
+		key: selectionTrackerKey,
+		state: {
+			init(_, state) {
+				return extractSelectionContext(state);
+			},
+			apply(tr, prevContext, _, newState) {
+				if (!tr.selectionSet && !tr.docChanged) return prevContext;
+				const newContext = extractSelectionContext(newState);
+				if (onSelectionChange && !contextsEqual(prevContext, newContext)) setTimeout(() => onSelectionChange(newContext), 0);
+				return newContext;
+			}
+		},
+		view() {
+			return { update(view, prevState) {
+				if (!onSelectionChange) return;
+				if (view.state.selection.eq(prevState.selection) && view.state.doc.eq(prevState.doc)) return;
+				const context = selectionTrackerKey.getState(view.state);
+				if (context) onSelectionChange(context);
+			} };
+		}
+	});
+}
+function arraysEqual(a, b) {
+	if (a === b) return true;
+	if (!a || !b || a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+/**
+* Compare two selection contexts for equality
+*/
+function contextsEqual(a, b) {
+	return a.hasSelection === b.hasSelection && a.isMultiParagraph === b.isMultiParagraph && a.startParagraphIndex === b.startParagraphIndex && a.endParagraphIndex === b.endParagraphIndex && a.inList === b.inList && a.listType === b.listType && a.listLevel === b.listLevel && a.inInsertion === b.inInsertion && a.inDeletion === b.inDeletion && arraysEqual(a.activeCommentIds, b.activeCommentIds) && JSON.stringify(a.textFormatting) === JSON.stringify(b.textFormatting) && JSON.stringify(a.paragraphFormatting) === JSON.stringify(b.paragraphFormatting);
+}
+/**
+* Get current selection context from editor state
+*/
+function getSelectionContext(state) {
+	return selectionTrackerKey.getState(state) || null;
+}
+//#endregion
+export { createSelectionTrackerPlugin, extractSelectionContext, getSelectionContext, selectionTrackerKey };

package/dist/prosemirror/plugins/suggestionMode.d.ts

@@ -0,0 +1,70 @@
+import { EditorState, Plugin, PluginKey, Transaction } from "prosemirror-state";
+import { Slice } from "prosemirror-model";
+import { EditorView } from "prosemirror-view";
+
+//#region src/prosemirror/plugins/suggestionMode.d.ts
+declare const suggestionModeKey: PluginKey<SuggestionModeState>;
+declare const SUGGESTION_META = "suggestionModeApplied";
+declare const SUGGESTION_BYPASS_META = "suggestionModeBypass";
+type SuggestionModeState = {
+  active: boolean;
+  author: string;
+};
+declare function makeRevisionInfo(state: EditorState): {
+  id: number;
+  author: string;
+  date: string;
+} | null;
+/**
+ * With track changes on, pasting over a non-empty text selection marks the
+ * replaced text as a tracked deletion and the pasted slice as a tracked
+ * insertion (so they read as one replacement), matching typing over a
+ * selection. Returns false for a collapsed cursor or non-text selection so the
+ * default paste + the `appendTransaction` catch-all marks a plain insertion
+ * (eigenpal/docx-editor#784).
+ */
+declare function handleSuggestionPaste(view: EditorView, slice: Slice, pluginState: SuggestionModeState): boolean;
+/**
+ * Track-changes Enter: split the paragraph and stamp `pPrMark = 'ins'` on the
+ * FIRST half of the split (the upper paragraph), per ECMA-376 §17.13.5. The
+ * actual splitting reuses `splitBlockClearBorders` so border/style/stored-mark
+ * behavior stays identical to ordinary editing.
+ *
+ * If the source paragraph already carries a `pPrMark`, leave it alone — a
+ * prior author's revision must not be silently overwritten.
+ */
+declare function handleSuggestionEnter(view: EditorView, pluginState: SuggestionModeState): boolean;
+/**
+ * Detect a caret-at-paragraph-boundary scenario where Backspace/Delete should
+ * record a tracked paragraph-mark deletion instead of joining paragraphs.
+ *
+ * Returns the position of the paragraph whose `pPrMark` should be set, or
+ * `null` if the caret is mid-paragraph (let the normal text-delete path run).
+ *
+ * - Backspace-at-paragraph-start → previous sibling paragraph.
+ * - Delete-at-paragraph-end     → current paragraph.
+ *
+ * Returns `null` when there is no adjacent sibling paragraph (the join would
+ * not produce paragraph-mark merging — e.g. doc start, doc end, or sibling
+ * is a table). The default merge path then runs unchanged.
+ */
+declare function paragraphBoundaryTarget(state: EditorState, direction: "backward" | "forward"): number | null;
+/**
+ * Create the suggestion mode plugin.
+ * When active, text edits become tracked changes.
+ */
+declare function createSuggestionModePlugin(initialActive?: boolean, author?: string): Plugin;
+/**
+ * Toggle suggestion mode on/off.
+ */
+declare function toggleSuggestionMode(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
+/**
+ * Set suggestion mode active state and author.
+ */
+declare function setSuggestionMode(active: boolean, state: EditorState, dispatch?: (tr: Transaction) => void, author?: string): boolean;
+/**
+ * Check if suggestion mode is currently active.
+ */
+declare function isSuggestionModeActive(state: EditorState): boolean;
+//#endregion
+export { SUGGESTION_BYPASS_META, SUGGESTION_META, createSuggestionModePlugin, handleSuggestionEnter, handleSuggestionPaste, isSuggestionModeActive, makeRevisionInfo, paragraphBoundaryTarget, setSuggestionMode, suggestionModeKey, toggleSuggestionMode };