@stll/folio-core 0.53.0 → 0.54.1

package/dist/prosemirror/plugins/templatePreviewValues.js

@@ -1,7 +1,7 @@
 import { scanDirectives } from "./templateDirectives.js";
 import { Plugin, PluginKey } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
-import { classifyMarker, isFieldPath } from "@stll/template-conditions";
+import { isFieldPath } from "@stll/template-conditions";
 //#region src/prosemirror/plugins/templatePreviewValues.ts
 /** Concatenated plain text of a preview value. */
 const templatePreviewValueText = (value) => typeof value === "string" ? value : value.runs.map((run) => run.text).join("");
@@ -64,28 +64,21 @@ function buildValueWidget(value, mode) {
 		return span;
 	};
 }
-/** Loop alias the bare-path probe binds. Any identifier does; it is discarded. */
-const CHAIN_PROBE_ALIAS = "__folioCondition";
 /** A field path opens with a letter or underscore, so `9x` and `-x` are not one. */
 const FIELD_PATH_HEAD_RE = /^[\p{L}_]/u;
 /**
 * The bare field path a condition's filter chain hangs off, or undefined when
-* the expression is not a path plus a chain.
+* the tag is not a path plus a chain.
 *
-* A host may write the tag the way `{% for x in xs | chain %}` already carries
-* one — `{% if buyer_is_a_consumer | checkbox | ai("Is the buyer …") %}` — while
-* keying `conditions` by the bare path. Splitting on `|` would cut a quoted
-* argument such as `label("a | b")` in half, so the expression is classified as
-* that very `for` chain instead and the grammar's own argument-aware scan
-* reports the path. An expression that is not a path plus a chain of known
-* filters (`a and b`, `items|length > 0`, `ai("a|b")`) classifies as nothing,
-* which is what keeps a real expression on exact matching.
+* A host may write the tag with the chain of the boolean it names —
+* `{% if buyer_is_a_consumer | checkbox | ai("Is the buyer …") %}` — while
+* keying `conditions` by the bare path. The grammar's argument-aware scan
+* splits the chain (`label("a | b")` stays one argument) and reports the path
+* as `conditionPath`; an expression that is not a path plus a chain of known
+* filters (`a and b`, `items|length > 0`, `ai("a|b")`) has none, which is what
+* keeps a real expression on exact matching.
 */
-const filterChainPath = (expr) => {
-	const meta = classifyMarker(`for ${CHAIN_PROBE_ALIAS} in ${expr}`, "statement");
-	if (meta?.kind !== "for" || !isFieldPath(meta.path) || !FIELD_PATH_HEAD_RE.test(meta.path)) return;
-	return meta.path;
-};
+const filterChainPath = ({ conditionPath }) => conditionPath !== void 0 && isFieldPath(conditionPath) && FIELD_PATH_HEAD_RE.test(conditionPath) ? conditionPath : void 0;
 /**
 * The verdict stored under one key. Only a key the host set itself, holding a
 * real boolean, counts: an inherited property (`constructor`, or a boolean the
@@ -102,10 +95,10 @@ const ownVerdict = (conditions, key) => {
 * by the bare path its filter chain hangs off. `undefined` means the host said
 * nothing about this block, which leaves it exactly as authored.
 */
-const conditionVerdict = (conditions, expr) => {
-	const exact = ownVerdict(conditions, expr);
+const conditionVerdict = (conditions, opener) => {
+	const exact = ownVerdict(conditions, opener.expr);
 	if (exact !== void 0) return exact;
-	const path = filterChainPath(expr);
+	const path = filterChainPath(opener);
 	return path === void 0 ? void 0 : ownVerdict(conditions, path);
 };
 /**
@@ -157,7 +150,7 @@ function collectHiddenRanges(ranges, conditions, mode) {
 		}
 		if (block === void 0 || block.opener.kind !== "if") continue;
 		const { opener, branches } = block;
-		const verdict = conditionVerdict(conditions, opener.expr);
+		const verdict = conditionVerdict(conditions, opener);
 		if (verdict === void 0) continue;
 		if (!verdict) {
 			paired.push({

package/dist/prosemirror/rebaseParagraphRunFormatting.d.ts

@@ -1,6 +1,7 @@
-import { RunStyleResolver } from "./runStyleFormatting.js";
+import { ParagraphRunStyleContext, RunStyleResolver } from "./runStyleFormatting.js";
 import { Node } from "prosemirror-model";
 import { Transaction } from "prosemirror-state";
+import { Transform } from "prosemirror-transform";
 //#region src/prosemirror/rebaseParagraphRunFormatting.d.ts
 type RebaseParagraphRunFormattingOptions = {
   nextAttrs: Record<string, unknown>;
@@ -9,10 +10,29 @@ type RebaseParagraphRunFormattingOptions = {
   styleResolver: RunStyleResolver;
   tr: Transaction;
 };
+type RebaseParagraphRunsOptions<T extends Transform> = {
+  /** The style context the runs' marks were resolved in. */
+  previousContext: ParagraphRunStyleContext;
+  paragraphPosition: number;
+  /** Content offsets inside the paragraph to rebase; all of it when omitted. */
+  range?: {
+    from: number;
+    to: number;
+  };
+  shouldRebase?: (node: Node) => boolean;
+  styleResolver: RunStyleResolver;
+  tr: T;
+};
+/**
+ * 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.
+ */
+declare const rebaseParagraphRuns: <T extends Transform>({ previousContext, paragraphPosition, range, shouldRebase, styleResolver, tr }: RebaseParagraphRunsOptions<T>) => T;
 /**
  * Change paragraph attrs and re-resolve inherited run marks in the new style
  * context without turning the old rendered style into direct run formatting.
  */
 declare const setParagraphAttrsWithRebasedRunFormatting: ({ nextAttrs, paragraphPosition, shouldRebase, styleResolver, tr }: RebaseParagraphRunFormattingOptions) => Transaction;
 //#endregion
-export { setParagraphAttrsWithRebasedRunFormatting };
+export { rebaseParagraphRuns, setParagraphAttrsWithRebasedRunFormatting };

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 };