@stll/folio-core 0.61.0 → 0.62.0

package/dist/prosemirror/fieldRepresentation.js

@@ -1,15 +1,17 @@
 import "./extensions/marks/InlineWrapperExtension.js";
+import { getInlineDisplayText } from "./inlineDisplayText.js";
 //#region src/prosemirror/fieldRepresentation.ts
 /** Current children alone decide whether a field needs editable structural content. */
 const fieldRequiresStructuredContent = (children) => children.some((child) => !child.isText || child.marks.some((mark) => mark.type.name === "hyperlink" || mark.type.name === "inlineWrapper" || mark.type.name === "insertion" || mark.type.name === "deletion"));
 /** Resolution returns text-only fields to the same atom representation as initial conversion. */
 const canonicalFieldNode = (node) => {
 	if (node.type.name !== "structuredField") return node;
+	const displayText = getInlineDisplayText(node);
 	const attrs = {
 		...node.attrs,
-		displayText: node.textContent
+		displayText
 	};
-	if (fieldRequiresStructuredContent(node.content.content)) return node.attrs["displayText"] === node.textContent ? node : node.type.create(attrs, node.content, node.marks);
+	if (fieldRequiresStructuredContent(node.content.content)) return node.attrs["displayText"] === displayText ? node : node.type.create(attrs, node.content, node.marks);
 	let marks = node.marks;
 	for (const mark of node.firstChild?.marks ?? []) marks = mark.addToSet(marks);
 	return node.type.schema.node("field", attrs, void 0, marks);

package/dist/prosemirror/findReplaceSelection.d.ts

@@ -1,5 +1,6 @@
+import { document_d_exports } from "../types/document.js";
 import { DisplayMode } from "../managers/EditorModeManager.js";
-import { FindOptions } from "../utils/findReplace.js";
+import { FindMatch, FindOptions, FindSearchContext } from "../utils/findReplace.js";
 import { Node } from "prosemirror-model";
 import { EditorState } from "prosemirror-state";
 //#region src/prosemirror/findReplaceSelection.d.ts
@@ -22,11 +23,25 @@ type FindMatchPosition = {
 type FindMatchRange = {
   from: number;
   to: number;
+  /** Navigation anchors inside a logical match are excluded from decorations. */
+  excludedRanges?: {
+    from: number;
+    to: number;
+  }[];
+  /** Character subranges inside source atoms, whose text exceeds their PM size. */
+  atomicTextRanges?: {
+    from: number;
+    to: number;
+    startOffset: number;
+    endOffset: number;
+  }[];
 };
 type ProseMirrorFindMatch = FindMatchPosition & FindMatchRange & {
   text: string;
 };
 declare function resolveFindMatchRange(doc: Node, match: FindMatchPosition): FindMatchRange | null;
+/** Resolve a result set in one paragraph traversal, preserving result order. */
+declare const resolveFindMatchRanges: (doc: Node, matches: readonly FindMatchPosition[]) => (FindMatchRange | null)[];
 declare function findInProseMirrorDocument(doc: Node, searchText: string, options: FindOptions): ProseMirrorFindMatch[];
 type FindInMarkupViewOptions = {
   state: EditorState;
@@ -36,5 +51,26 @@ type FindInMarkupViewOptions = {
 };
 /** Search the displayed story; returned ranges address the authored editor document. */
 declare const findInMarkupView: ({ state, markupView, searchText, options }: FindInMarkupViewOptions) => ProseMirrorFindMatch[];
+type FindInDisplayedDocumentOptions = {
+  document: document_d_exports.Document;
+  /**
+   * Live body editor state. A review view reads its body from this state's
+   * projection, so null defers that search until the body editor mounts.
+   * Hosts without an editor state omit it and search the package model.
+   */
+  state?: EditorState | null | undefined;
+  searchText: string;
+  options: FindOptions;
+  context?: FindSearchContext | undefined;
+};
+/**
+ * Search every story a display mode shows. All Markup searches the package
+ * stories. A resolved review view searches its body through the projection the
+ * layout paints, so body ranges address the authored editor document; anchored
+ * shapes, headers, footers, notes and comments keep the package search owner
+ * with the same display mode. Returns null while a review view has no body
+ * editor state to project.
+ */
+declare const findInDisplayedDocument: ({ document, state, searchText, options, context }: FindInDisplayedDocumentOptions) => FindMatch[] | null;
 //#endregion
-export { FindMatchPosition, FindMatchRange, ProseMirrorFindMatch, findInMarkupView, findInProseMirrorDocument, resolveFindMatchRange };
+export { FindMatchPosition, FindMatchRange, ProseMirrorFindMatch, findInDisplayedDocument, findInMarkupView, findInProseMirrorDocument, resolveFindMatchRange, resolveFindMatchRanges };

package/dist/prosemirror/findReplaceSelection.js

@@ -1,6 +1,6 @@
-import { findAllMatches } from "../utils/findReplace.js";
-import { decodeOoxmlSymbolCharacter } from "../utils/ooxmlSymbol.js";
-import { expectSymbolAttrs } from "./attrs/index.js";
+import { findAllMatches, findInDocument, isPageDependentSearchField } from "../utils/findReplace.js";
+import { expectFieldAttrs } from "./attrs/index.js";
+import { getInlineDisplayText, getInlineDisplayToken, isNoteReferenceText } from "./inlineDisplayText.js";
 import { projectMarkupView } from "./markupViewProjection.js";
 //#region src/prosemirror/findReplaceSelection.ts
 function resolveFindMatchRange(doc, match) {
@@ -17,11 +17,29 @@ function resolveFindMatchRange(doc, match) {
 	});
 	return resolved;
 }
+/** Resolve a result set in one paragraph traversal, preserving result order. */
+const resolveFindMatchRanges = (doc, matches) => {
+	const paragraphs = /* @__PURE__ */ new Map();
+	forEachSearchParagraph(doc, (paragraph, paragraphPos, paragraphIndex) => {
+		paragraphs.set(paragraphIndex, {
+			paragraph,
+			paragraphPos
+		});
+		return true;
+	});
+	return matches.map((match) => {
+		const paragraph = paragraphs.get(match.paragraphIndex);
+		return paragraph ? resolveTextRangeInParagraph({
+			...paragraph,
+			...match
+		}) : null;
+	});
+};
 function findInProseMirrorDocument(doc, searchText, options) {
 	if (!searchText) return [];
 	const matches = [];
 	forEachSearchParagraph(doc, (paragraph, paragraphPos, paragraphIndex) => {
-		const text = getSearchableParagraphText(paragraph);
+		const text = getInlineDisplayText(paragraph);
 		for (const { start, end } of findAllMatches(text, searchText, options)) {
 			const range = resolveTextRangeInParagraph({
 				paragraph,
@@ -45,14 +63,95 @@ function findInProseMirrorDocument(doc, searchText, options) {
 const findInMarkupView = ({ state, markupView, searchText, options }) => {
 	const projection = projectMarkupView(state, markupView);
 	if (projection.type === "authored") return findInProseMirrorDocument(state.doc, searchText, options);
-	return findInProseMirrorDocument(projection.doc, searchText, options).map((match) => ({
+	return findInProseMirrorDocument(projection.doc, searchText, options).map((match) => toAuthoredFindMatch(projection, match));
+};
+/** Every view-document position a match carries, mapped to the authored editor document. */
+const toAuthoredFindMatch = (projection, match) => {
+	const toEditorRange = ({ from, to }) => ({
+		from: projection.toEditor(from, 1),
+		to: projection.toEditor(to, -1)
+	});
+	return {
 		paragraphIndex: match.paragraphIndex,
 		startOffset: match.startOffset,
 		endOffset: match.endOffset,
 		text: match.text,
-		from: projection.toEditor(match.from, 1),
-		to: projection.toEditor(match.to, -1)
-	}));
+		...toEditorRange(match),
+		...match.excludedRanges && { excludedRanges: match.excludedRanges.map(toEditorRange) },
+		...match.atomicTextRanges && { atomicTextRanges: match.atomicTextRanges.map((atom) => ({
+			...toEditorRange(atom),
+			startOffset: atom.startOffset,
+			endOffset: atom.endOffset
+		})) }
+	};
+};
+/** Replacement policy for a projected body match, in the shared eligibility vocabulary. */
+const projectedReplacement = (state, viewMatch, authored) => {
+	const atom = authored.atomicTextRanges?.at(0);
+	if (atom) return {
+		status: "blocked",
+		reason: state.doc.nodeAt(atom.from)?.type.name === "field" ? "field-result" : "atomic-content"
+	};
+	return authored.to - authored.from === viewMatch.to - viewMatch.from ? { status: "allowed" } : {
+		status: "blocked",
+		reason: "hidden-content"
+	};
+};
+/**
+* Search every story a display mode shows. All Markup searches the package
+* stories. A resolved review view searches its body through the projection the
+* layout paints, so body ranges address the authored editor document; anchored
+* shapes, headers, footers, notes and comments keep the package search owner
+* with the same display mode. Returns null while a review view has no body
+* editor state to project.
+*/
+const findInDisplayedDocument = ({ document, state, searchText, options, context }) => {
+	const displayMode = options.displayMode ?? "all-markup";
+	if (displayMode === "all-markup" || state === void 0) return findInDocument(document, searchText, options, context);
+	if (state === null) return null;
+	const packageMatches = findInDocument(document, searchText, options, context);
+	const projection = projectMarkupView(state, displayMode);
+	if (projection.type === "authored" || !searchText) return packageMatches;
+	const bodyMatches = findInProseMirrorDocument(projection.doc, searchText, options).map((viewMatch) => {
+		const authored = toAuthoredFindMatch(projection, viewMatch);
+		const { from, to, excludedRanges, atomicTextRanges } = authored;
+		return {
+			paragraphIndex: authored.paragraphIndex,
+			contentIndex: 0,
+			startOffset: authored.startOffset,
+			endOffset: authored.endOffset,
+			text: authored.text,
+			story: "main",
+			replacement: projectedReplacement(state, viewMatch, authored),
+			authoredRange: {
+				from,
+				to,
+				...excludedRanges && { excludedRanges },
+				...atomicTextRanges && { atomicTextRanges }
+			}
+		};
+	});
+	const anchorEnds = [];
+	forEachSearchParagraph(state.doc, (paragraph, paragraphPos, paragraphIndex) => {
+		anchorEnds[paragraphIndex] = paragraphPos + paragraph.nodeSize;
+		return true;
+	});
+	const bodyShapeMatches = packageMatches.filter((match) => match.story === "main" && match.textBoxIndex !== void 0);
+	const orderedBody = [];
+	let shapeIndex = 0;
+	const shapeAnchorEnd = (match) => match.anchorParagraphIndex !== void 0 && anchorEnds[match.anchorParagraphIndex] || Number.POSITIVE_INFINITY;
+	for (const bodyMatch of bodyMatches) {
+		const from = bodyMatch.authoredRange?.from ?? 0;
+		while (shapeIndex < bodyShapeMatches.length) {
+			const shapeMatch = bodyShapeMatches[shapeIndex];
+			if (!shapeMatch || shapeAnchorEnd(shapeMatch) > from) break;
+			orderedBody.push(shapeMatch);
+			shapeIndex++;
+		}
+		orderedBody.push(bodyMatch);
+	}
+	orderedBody.push(...bodyShapeMatches.slice(shapeIndex));
+	return [...orderedBody, ...packageMatches.filter((match) => match.story !== "main" || match.textBoxIndex === void 0 && match.commentId !== void 0)];
 };
 function forEachSearchParagraph(doc, visit) {
 	let paragraphIndex = 0;
@@ -103,54 +202,56 @@ function resolveTextRangeInParagraph({ paragraph, paragraphPos, startOffset, end
 		to: null
 	};
 	const pageBreakOffsets = [];
+	const excludedTextRanges = [];
+	const excludedRanges = [];
+	const atomicTextRanges = [];
 	paragraph.descendants((node, pos) => {
+		if ((node.type.name === "field" || node.type.name === "structuredField") && isPageDependentSearchField(expectFieldAttrs(node).instruction)) {
+			const length = node.type.name === "field" ? expectFieldAttrs(node).displayText.length : getInlineDisplayText(node).length;
+			excludedTextRanges.push({
+				start: textOffset,
+				end: textOffset + length
+			});
+		}
 		if (node.type.name === "pageBreakRun") {
 			pageBreakOffsets.push(textOffset);
 			return false;
 		}
+		if (isNoteReferenceText(node)) {
+			const from = paragraphPos + 1 + pos;
+			excludedRanges.push({
+				from,
+				to: from + node.nodeSize
+			});
+		}
 		const tokenLength = getSearchTextTokenLength(node);
 		if (tokenLength === 0) return true;
 		const textStart = textOffset;
 		const textEnd = textStart + tokenLength;
 		const nodeStart = paragraphPos + 1 + pos;
-		if (range.from === null && startOffset >= textStart && startOffset < textEnd) range.from = nodeStart + Math.min(startOffset - textStart, node.nodeSize);
-		if (range.to === null && endOffset > textStart && endOffset <= textEnd) range.to = nodeStart + Math.min(endOffset - textStart, node.nodeSize);
+		const atomic = node.type.name === "field" || node.type.name === "preservedXml";
+		if (atomic && textStart < endOffset && textEnd > startOffset) atomicTextRanges.push({
+			from: nodeStart,
+			to: nodeStart + node.nodeSize,
+			startOffset: Math.max(0, startOffset - textStart),
+			endOffset: Math.min(tokenLength, endOffset - textStart)
+		});
+		if (range.from === null && startOffset >= textStart && startOffset < textEnd) range.from = atomic ? nodeStart : nodeStart + Math.min(startOffset - textStart, node.nodeSize);
+		if (range.to === null && endOffset > textStart && endOffset <= textEnd) range.to = atomic ? nodeStart + node.nodeSize : nodeStart + Math.min(endOffset - textStart, node.nodeSize);
 		textOffset = textEnd;
 		return range.to === null;
 	});
-	if (range.from === null || range.to === null || range.from >= range.to || pageBreakOffsets.some((offset) => offset > startOffset && offset < endOffset)) return null;
+	if (range.from === null || range.to === null || range.from >= range.to || pageBreakOffsets.some((offset) => offset > startOffset && offset < endOffset) || excludedTextRanges.some(({ start, end }) => start < endOffset && end > startOffset)) return null;
+	const from = range.from;
+	const to = range.to;
+	const visibleExcludedRanges = excludedRanges.filter((anchor) => anchor.from < to && anchor.to > from);
 	return {
-		from: range.from,
-		to: range.to
+		from,
+		to,
+		...atomicTextRanges.length > 0 && { atomicTextRanges },
+		...visibleExcludedRanges.length > 0 && { excludedRanges: visibleExcludedRanges }
 	};
 }
-function getSearchTextTokenLength(node) {
-	if (node.isText) return node.text?.length ?? 0;
-	if (node.type.name === "tab" || node.type.name === "hardBreak" || node.type.name === "symbol") return 1;
-	return 0;
-}
-function getSearchableParagraphText(paragraph) {
-	let text = "";
-	paragraph.descendants((node) => {
-		if (node.isText) {
-			text += node.text ?? "";
-			return false;
-		}
-		if (node.type.name === "tab") {
-			text += "	";
-			return false;
-		}
-		if (node.type.name === "hardBreak") {
-			text += "\n";
-			return false;
-		}
-		if (node.type.name === "symbol") {
-			text += decodeOoxmlSymbolCharacter(expectSymbolAttrs(node).char) ?? "";
-			return false;
-		}
-		return true;
-	});
-	return text;
-}
+const getSearchTextTokenLength = (node) => getInlineDisplayToken(node)?.length ?? 0;
 //#endregion
-export { findInMarkupView, findInProseMirrorDocument, resolveFindMatchRange };
+export { findInDisplayedDocument, findInMarkupView, findInProseMirrorDocument, resolveFindMatchRange, resolveFindMatchRanges };

package/dist/prosemirror/inlineDisplayText.d.ts

@@ -0,0 +1,10 @@
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/inlineDisplayText.d.ts
+/** Native note-reference labels are navigation anchors, outside searchable text. */
+declare const isNoteReferenceText: (node: Node) => boolean;
+/** A leaf's logical text; null means a transparent container to descend into. */
+declare const getInlineDisplayToken: (node: Node) => string | null;
+/** Visible inline text, including cached source atoms and native run tokens. */
+declare const getInlineDisplayText: (paragraph: Node) => string;
+//#endregion
+export { getInlineDisplayText, getInlineDisplayToken, isNoteReferenceText };

package/dist/prosemirror/inlineDisplayText.js

@@ -0,0 +1,29 @@
+import { decodeOoxmlSymbolCharacter } from "../utils/ooxmlSymbol.js";
+import { expectFieldAttrs, expectPreservedXmlAttrs, expectSymbolAttrs } from "./attrs/index.js";
+//#region src/prosemirror/inlineDisplayText.ts
+/** Native note-reference labels are navigation anchors, outside searchable text. */
+const isNoteReferenceText = (node) => node.isText && node.marks.some((mark) => mark.type.name === "footnoteRef");
+/** A leaf's logical text; null means a transparent container to descend into. */
+const getInlineDisplayToken = (node) => {
+	if (isNoteReferenceText(node)) return "";
+	if (node.type.name === "field") return expectFieldAttrs(node).displayText;
+	if (node.type.name === "preservedXml") return expectPreservedXmlAttrs(node).text;
+	if (node.isText) return node.text ?? "";
+	if (node.type.name === "tab") return "	";
+	if (node.type.name === "hardBreak") return "\n";
+	if (node.type.name === "symbol") return decodeOoxmlSymbolCharacter(expectSymbolAttrs(node).char) ?? "";
+	return null;
+};
+/** Visible inline text, including cached source atoms and native run tokens. */
+const getInlineDisplayText = (paragraph) => {
+	let text = "";
+	paragraph.descendants((node) => {
+		const token = getInlineDisplayToken(node);
+		if (token === null) return true;
+		text += token;
+		return false;
+	});
+	return text;
+};
+//#endregion
+export { getInlineDisplayText, getInlineDisplayToken, isNoteReferenceText };

package/dist/prosemirror/trackedRunInlineAtoms.d.ts

@@ -21,7 +21,7 @@ declare const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS: Readonly<{
   readonly pageBreakRun: "page-break-carrier";
   readonly preservedXml: "carry";
   readonly rangeAnchor: "transparent";
-  readonly renderedPageBreak: "transparent";
+  readonly renderedPageBreak: "carry";
   readonly shape: "carry";
   readonly structuredField: "carry";
   readonly symbol: "carry";

package/dist/prosemirror/trackedRunInlineAtoms.js

@@ -20,7 +20,7 @@ const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS = Object.freeze({
 	pageBreakRun: "page-break-carrier",
 	preservedXml: "carry",
 	rangeAnchor: "transparent",
-	renderedPageBreak: "transparent",
+	renderedPageBreak: "carry",
 	shape: "carry",
 	structuredField: "carry",
 	symbol: "carry",

package/dist/utils/findMatchView.d.ts

@@ -0,0 +1,32 @@
+import { document_d_exports } from "../types/document.js";
+import { Layout } from "../layout-engine/types.js";
+import { FindMatch } from "./findReplace.js";
+import { FindMatchRange } from "../prosemirror/findReplaceSelection.js";
+import { Node } from "prosemirror-model";
+import { OpStory } from "@stll/docx-core/ops";
+//#region src/utils/findMatchView.d.ts
+/** The same page variant selection used by the painter, including unmounted pages. */
+declare const getRenderedSearchStories: (layout: Layout | null) => OpStory[];
+type ResolvedMatch = FindMatchRange & {
+  index: number;
+  story: OpStory;
+};
+type FindMatchViewOptions = {
+  container: HTMLElement;
+  document: document_d_exports.Document;
+  bodyDoc?: Node | undefined;
+  matches: readonly FindMatch[];
+  commentRoot?: HTMLElement | undefined;
+  layout?: Layout | null | undefined;
+};
+/** Resolve each story once; box positions are local to their parent story. */
+declare const resolveDocumentFindRanges: ({ document, bodyDoc, matches }: Omit<FindMatchViewOptions, "container" | "commentRoot" | "layout">) => ResolvedMatch[];
+/** Paint search geometry over the existing page DOM, without changing editor state. */
+declare const createFindMatchView: (options: FindMatchViewOptions) => {
+  paint: (index: number) => void;
+  reveal: (index: number) => boolean;
+  navigate: (index: number, activateComment?: (commentId: number) => void) => void;
+  destroy: () => void;
+};
+//#endregion
+export { createFindMatchView, getRenderedSearchStories, resolveDocumentFindRanges };