@stll/folio-core 0.53.0 → 0.54.0

package/dist/prosemirror/rebaseParagraphRunFormatting.js

@@ -1,3 +1,4 @@
+import { sameRunStyleContext } from "./rebaseParagraphRuns.js";
 import { expandRunFormattingCarrier } from "./runFormattingInlineCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
 import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
@@ -5,18 +6,23 @@ import { paragraphRunStyleContext } from "./runStyleFormatting.js";
 import { panic } from "better-result";
 import { Mark } from "prosemirror-model";
 //#region src/prosemirror/rebaseParagraphRunFormatting.ts
-/**
-* Change paragraph attrs and re-resolve inherited run marks in the new style
-* context without turning the old rendered style into direct run formatting.
-*/
-const setParagraphAttrsWithRebasedRunFormatting = ({ nextAttrs, paragraphPosition, shouldRebase, styleResolver, tr }) => {
+const paragraphAt = (tr, paragraphPosition) => {
 	const paragraph = tr.doc.nodeAt(paragraphPosition);
 	if (!paragraph || paragraph.type.name !== "paragraph") return panic("Cannot rebase run formatting outside a paragraph", {
 		nodeType: paragraph?.type.name,
 		paragraphPosition
 	});
-	const previousContext = paragraphRunStyleContext(paragraph, styleResolver);
-	const nextContext = paragraphRunStyleContext(paragraph.type.create(nextAttrs, paragraph.content, paragraph.marks), styleResolver);
+	return paragraph;
+};
+/**
+* Re-resolve the inherited marks of runs resolved in `previousContext` in the
+* paragraph's current style context: direct formatting stays direct, and what
+* the old context lent the runs goes with it.
+*/
+const rebaseParagraphRuns = ({ previousContext, paragraphPosition, range, shouldRebase, styleResolver, tr }) => {
+	const paragraph = paragraphAt(tr, paragraphPosition);
+	const nextContext = paragraphRunStyleContext(paragraph, styleResolver);
+	if (sameRunStyleContext(previousContext, nextContext)) return tr;
 	const changes = [];
 	const collectRebasedRepresentation = ({ node, position }) => {
 		if (shouldRebase && !shouldRebase(node)) return;
@@ -31,23 +37,28 @@ const setParagraphAttrsWithRebasedRunFormatting = ({ nextAttrs, paragraphPositio
 			styleResolver
 		});
 		if (Mark.sameSet(node.marks, nextMarks)) return;
+		const start = paragraphPosition + 1;
+		const from = node.isText && range ? Math.max(position, start + range.from) : position;
+		const to = node.isText && range ? Math.min(position + node.nodeSize, start + range.to) : position + node.nodeSize;
+		if (to <= from) return;
 		changes.push({
 			attrs: node.attrs,
 			currentFormattingMarks: node.marks.filter(({ type }) => RUN_FORMATTING_MARK_NAMES.has(type.name)),
-			from: position,
+			from,
 			isText: node.isText,
 			marks: nextMarks,
-			to: position + node.nodeSize
+			to
 		});
 	};
-	paragraph.descendants((node, relativePosition) => {
+	const visit = (node, relativePosition) => {
 		if (!node.isInline) return true;
 		const carrier = expandRunFormattingCarrier(node, paragraphPosition + 1 + relativePosition);
 		if (!carrier) return !node.isAtom;
 		for (const representation of carrier.representations) collectRebasedRepresentation(representation);
 		return false;
-	});
-	tr = tr.setNodeMarkup(paragraphPosition, void 0, nextAttrs);
+	};
+	if (range === void 0) paragraph.descendants(visit);
+	else paragraph.nodesBetween(range.from, range.to, visit);
 	for (const { attrs, currentFormattingMarks, from, isText, marks, to } of changes) {
 		if (!isText) {
 			tr = tr.setNodeMarkup(from, void 0, attrs, marks);
@@ -58,5 +69,20 @@ const setParagraphAttrsWithRebasedRunFormatting = ({ nextAttrs, paragraphPositio
 	}
 	return tr;
 };
+/**
+* Change paragraph attrs and re-resolve inherited run marks in the new style
+* context without turning the old rendered style into direct run formatting.
+*/
+const setParagraphAttrsWithRebasedRunFormatting = ({ nextAttrs, paragraphPosition, shouldRebase, styleResolver, tr }) => {
+	const previousContext = paragraphRunStyleContext(paragraphAt(tr, paragraphPosition), styleResolver);
+	tr = tr.setNodeMarkup(paragraphPosition, void 0, nextAttrs);
+	return rebaseParagraphRuns({
+		previousContext,
+		paragraphPosition,
+		...shouldRebase ? { shouldRebase } : {},
+		styleResolver,
+		tr
+	});
+};
 //#endregion
-export { setParagraphAttrsWithRebasedRunFormatting };
+export { rebaseParagraphRuns, setParagraphAttrsWithRebasedRunFormatting };

package/dist/prosemirror/rebaseParagraphRuns.d.ts

@@ -0,0 +1,36 @@
+import { ParagraphRunStyleContext, RunStyleResolver } from "./runStyleFormatting.js";
+import { Fragment, Mark, Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+//#region src/prosemirror/rebaseParagraphRuns.d.ts
+/** Two contexts that lend runs the same formatting: rebasing between them changes nothing. */
+declare const sameRunStyleContext: (source: ParagraphRunStyleContext, target: ParagraphRunStyleContext) => boolean;
+type RebaseParagraphRunsOptions = {
+  tr: Transaction;
+  position: number;
+  previous: Node;
+  target?: Node;
+  styleResolver: RunStyleResolver | null;
+  range?: {
+    from: number;
+    to: number;
+  };
+  storedMarks?: readonly Mark[] | null;
+};
+/** Rebuild rendered marks after the paragraph's style cascade changes. */
+declare const rebaseParagraphRuns: ({ tr, position, previous, target, styleResolver, range, storedMarks: initialStoredMarks }: RebaseParagraphRunsOptions) => Transaction;
+type RebasedRunFormatting = {
+  before: Node;
+  after: Node;
+  position: number;
+};
+type RebaseParagraphRunContentOptions = {
+  paragraph: Node;
+  target: Node;
+  position: number;
+  styleResolver: RunStyleResolver | null;
+  onRebased: (resolution: RebasedRunFormatting) => void;
+};
+/** Rebase an immutable paragraph chunk once, before assembling a resolved join chain. */
+declare const rebaseParagraphRunContent: ({ paragraph, target, position, styleResolver, onRebased }: RebaseParagraphRunContentOptions) => Fragment;
+//#endregion
+export { rebaseParagraphRunContent, rebaseParagraphRuns, sameRunStyleContext };

package/dist/prosemirror/rebaseParagraphRuns.js

@@ -0,0 +1,99 @@
+import { recreateProseNodeWithParagraphPropertySource } from "../docx/paragraphPropertySource.js";
+import { formattingEquals } from "../docx/runConsolidator.js";
+import { applyMarksToRunFormattingRepresentation, selectRunFormattingCarrierRepresentations } from "./runFormattingInlineCarriers.js";
+import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
+import { paragraphRunStyleContext } from "./runStyleFormatting.js";
+import { Mark } from "prosemirror-model";
+//#region src/prosemirror/rebaseParagraphRuns.ts
+/** Two contexts that lend runs the same formatting: rebasing between them changes nothing. */
+const sameRunStyleContext = (source, target) => source.paragraphMarkPrecedesStyle === target.paragraphMarkPrecedesStyle && formattingEquals(source.baseParagraphFormatting, target.baseParagraphFormatting) && formattingEquals(source.paragraphFormatting, target.paragraphFormatting) && formattingEquals(source.paragraphMarkFormatting, target.paragraphMarkFormatting);
+/** Rebuild rendered marks after the paragraph's style cascade changes. */
+const rebaseParagraphRuns = ({ tr, position, previous, target, styleResolver, range, storedMarks: initialStoredMarks }) => {
+	const paragraph = tr.doc.nodeAt(position);
+	if (!paragraph) return tr;
+	const storedMarks = initialStoredMarks ?? tr.storedMarks ?? tr.selection.$from.marks();
+	const sourceContext = paragraphRunStyleContext(previous, styleResolver);
+	const targetContext = paragraphRunStyleContext(target ?? paragraph, styleResolver);
+	const sameCascade = sameRunStyleContext(sourceContext, targetContext);
+	const representations = sameCascade ? [] : selectRunFormattingCarrierRepresentations({
+		doc: tr.doc,
+		from: range?.from ?? position + 1,
+		to: range?.to ?? position + paragraph.nodeSize - 1
+	});
+	for (const representation of representations) applyMarksToRunFormattingRepresentation({
+		tr,
+		representation,
+		marks: reconcileRunFormattingMarks({
+			authoredFormatting: readAuthoredRunFormatting({
+				context: sourceContext,
+				marks: representation.node.marks,
+				styleResolver
+			}),
+			context: targetContext,
+			node: representation.node,
+			styleResolver
+		})
+	});
+	if (target === void 0 && range === void 0 && tr.selection.empty && tr.selection.from > position && tr.selection.from < position + paragraph.nodeSize) {
+		const node = paragraph.type.schema.text(" ", storedMarks);
+		tr.setStoredMarks(sameCascade ? storedMarks : reconcileRunFormattingMarks({
+			authoredFormatting: readAuthoredRunFormatting({
+				context: sourceContext,
+				marks: node.marks,
+				styleResolver
+			}),
+			context: targetContext,
+			node,
+			styleResolver
+		}));
+	}
+	return tr;
+};
+/** Rebase an immutable paragraph chunk once, before assembling a resolved join chain. */
+const rebaseParagraphRunContent = ({ paragraph, target, position, styleResolver, onRebased }) => {
+	const sourceContext = paragraphRunStyleContext(paragraph, styleResolver);
+	const targetContext = paragraphRunStyleContext(target, styleResolver);
+	if (sameRunStyleContext(sourceContext, targetContext)) return paragraph.content;
+	const replacements = /* @__PURE__ */ new Map();
+	const representations = selectRunFormattingCarrierRepresentations({
+		doc: paragraph,
+		from: 0,
+		to: paragraph.content.size
+	});
+	for (const representation of representations) {
+		const marks = reconcileRunFormattingMarks({
+			authoredFormatting: readAuthoredRunFormatting({
+				context: sourceContext,
+				marks: representation.node.marks,
+				styleResolver
+			}),
+			context: targetContext,
+			node: representation.node,
+			styleResolver
+		});
+		if (Mark.sameSet(marks, representation.node.marks)) continue;
+		const rebased = representation.node.mark(marks);
+		replacements.set(representation.node, rebased);
+		onRebased({
+			before: representation.node,
+			after: rebased,
+			position: position + 1 + representation.position
+		});
+	}
+	if (replacements.size === 0) return paragraph.content;
+	const rebuild = (node) => {
+		const replacement = replacements.get(node) ?? node;
+		if (node.isLeaf) return replacement;
+		const children = [];
+		let changed = false;
+		replacement.forEach((child) => {
+			const next = rebuild(child);
+			children.push(next);
+			changed ||= next !== child;
+		});
+		return changed ? recreateProseNodeWithParagraphPropertySource(replacement, { content: children }) : replacement;
+	};
+	return rebuild(paragraph).content;
+};
+//#endregion
+export { rebaseParagraphRunContent, rebaseParagraphRuns, sameRunStyleContext };

package/dist/prosemirror/runFormattingFromMarks.d.ts

@@ -0,0 +1,18 @@
+import { document_d_exports } from "../types/document.js";
+import { RunStyleResolver } from "./runStyleFormatting.js";
+import { Mark } from "prosemirror-model";
+//#region src/prosemirror/runFormattingFromMarks.d.ts
+/**
+ * Convert ProseMirror marks to TextFormatting
+ */
+type MarksToTextFormattingOptions = {
+  baseParagraphFormatting?: document_d_exports.TextFormatting | undefined;
+  inheritedFormatting?: document_d_exports.TextFormatting | undefined;
+  paragraphMarkFormatting?: document_d_exports.TextFormatting | undefined;
+  paragraphMarkPrecedesStyle?: boolean | undefined;
+  styleResolver?: RunStyleResolver | null | undefined;
+};
+declare const sameFormattingValue: (left: unknown, right: unknown) => boolean;
+declare function marksToTextFormatting(marks: readonly Mark[], options?: MarksToTextFormattingOptions): document_d_exports.TextFormatting;
+//#endregion
+export { MarksToTextFormattingOptions, marksToTextFormatting, sameFormattingValue };