@stll/folio-core 0.42.0 → 0.43.0

package/dist/prosemirror/pageBreakRunProjection.js

@@ -4,10 +4,10 @@ const PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES = {
 	borders: "A bordered paragraph containing an explicit page-break run cannot be projected",
 	frame: "A framed paragraph containing an explicit page-break run cannot be projected",
 	outline: "An outline paragraph containing an explicit page-break run cannot be projected",
-	textBoxAnchor: "A paragraph containing both an explicit page-break run and a text-box anchor cannot be projected"
+	textBoxAnchor: "A paragraph whose text-box anchor follows an explicit page-break run cannot be projected"
 };
 /** Keep source-import and ProseMirror-layout ownership decisions on one predicate. */
-const pageBreakRunParagraphProjectionDispositionForFeatures = ({ attrs, effectiveFrame, hasTextBoxAnchor }) => {
+const pageBreakRunParagraphProjectionDispositionForFeatures = ({ attrs, effectiveFrame, textBoxAnchorAfterPageBreak }) => {
 	if (effectiveFrame !== void 0 && effectiveFrame.dropCap !== "drop" && effectiveFrame.dropCap !== "margin") return {
 		status: "unsupported",
 		reason: "frame",
@@ -23,7 +23,7 @@ const pageBreakRunParagraphProjectionDispositionForFeatures = ({ attrs, effectiv
 		reason: "borders",
 		message: PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES.borders
 	};
-	if (hasTextBoxAnchor) return {
+	if (textBoxAnchorAfterPageBreak) return {
 		status: "unsupported",
 		reason: "textBoxAnchor",
 		message: PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES.textBoxAnchor
@@ -32,15 +32,23 @@ const pageBreakRunParagraphProjectionDispositionForFeatures = ({ attrs, effectiv
 };
 const pageBreakRunParagraphProjectionDisposition = (paragraph) => {
 	const attrs = expectParagraphAttrs(paragraph);
-	let hasTextBoxAnchor = false;
-	paragraph.descendants((descendant) => {
-		hasTextBoxAnchor ||= descendant.type.name === "textBoxAnchor";
-		return !hasTextBoxAnchor;
+	let firstPageBreakPos;
+	let textBoxAnchorAfterPageBreak = false;
+	paragraph.descendants((descendant, pos) => {
+		if (descendant.type.name === "pageBreakRun") {
+			firstPageBreakPos ??= pos;
+			return false;
+		}
+		if (descendant.type.name === "textBoxAnchor" && firstPageBreakPos !== void 0) {
+			textBoxAnchorAfterPageBreak = true;
+			return false;
+		}
+		return !textBoxAnchorAfterPageBreak;
 	});
 	return pageBreakRunParagraphProjectionDispositionForFeatures({
 		attrs,
 		effectiveFrame: attrs._originalFormatting?.frame,
-		hasTextBoxAnchor
+		textBoxAnchorAfterPageBreak
 	});
 };
 //#endregion

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

@@ -25,6 +25,19 @@ type TemplatePreviewValues = {
   values: Record<string, TemplatePreviewValue>;
   /** `highlighted` marks substitutions with the preview accent. */
   mode: "highlighted" | "plain";
+  /**
+   * `if` expression → whether its block applies. The key is the expression
+   * exactly as written between `{% if` and `%}`, trimmed; a tag that carries a
+   * filter chain (`{% if consented | checkbox | label("…") %}`) also answers to
+   * the bare path in front of the chain, so a host that keys by field path need
+   * not repeat the chain. An expression the map does not mention is left as
+   * authored. The host decides truthiness: folio evaluates nothing.
+   *
+   * `false` hides the block, opener through closer. `true` keeps the body and,
+   * in `plain` mode, drops the block's tag paragraphs so the reader sees what
+   * will be generated; `highlighted` mode keeps them.
+   */
+  conditions?: Record<string, boolean>;
 };
 /**
  * One `{{path}}` marker matched by an active preview value. Exposed on
@@ -41,9 +54,37 @@ type TemplatePreviewEntry = {
   /** The typed value displayed in place of the marker. */
   value: TemplatePreviewValue;
 };
+/**
+ * One span the preview hides: a `false` block from its opener through its
+ * closer, or a single directive tag of a `true` block in `plain` mode. Exposed
+ * on the plugin state beside {@link TemplatePreviewEntry} so a surface that
+ * never sees PM decorations can drop the same spans.
+ */
+type TemplatePreviewHiddenRange = {
+  /** Inclusive PM doc position of the span start. */
+  from: number;
+  /** Exclusive PM doc position of the span end. */
+  to: number;
+  /** The `if` expression of the block this span belongs to, as authored. */
+  expr: string;
+};
+/**
+ * Whether a hidden span swallows a block whole, i.e. covers every position of
+ * its content, leaving it nothing to render. `pmStart`/`pmEnd` are the block
+ * node's own positions, so its content is `[pmStart + 1, pmEnd - 1)`.
+ *
+ * The decoration path and the paged flow both drop a block on this predicate,
+ * so the two surfaces hide exactly the same blocks; a block only partly covered
+ * fails it and keeps its text, and the covered span alone is hidden.
+ */
+declare const templatePreviewHidesWholeBlock: (range: TemplatePreviewHiddenRange, block: {
+  pmStart: number;
+  pmEnd: number;
+}) => boolean;
 type TemplatePreviewState = {
   preview: TemplatePreviewValues | null;
   entries: TemplatePreviewEntry[];
+  hidden: TemplatePreviewHiddenRange[];
   decorationSet: DecorationSet;
 };
 declare const templatePreviewValuesKey: PluginKey<TemplatePreviewState>;
@@ -51,4 +92,4 @@ declare function createTemplatePreviewValuesPlugin(): Plugin<TemplatePreviewStat
 /** Push (or clear, with `null`) the live fill preview into the editor. */
 declare const setTemplatePreviewValues: (view: EditorView, preview: TemplatePreviewValues | null) => void;
 //#endregion
-export { TemplatePreviewEntry, TemplatePreviewSpan, TemplatePreviewValue, TemplatePreviewValues, createTemplatePreviewValuesPlugin, setTemplatePreviewValues, templatePreviewValueFingerprint, templatePreviewValueText, templatePreviewValuesKey };
+export { TemplatePreviewEntry, TemplatePreviewHiddenRange, TemplatePreviewSpan, TemplatePreviewValue, TemplatePreviewValues, createTemplatePreviewValuesPlugin, setTemplatePreviewValues, templatePreviewHidesWholeBlock, templatePreviewValueFingerprint, templatePreviewValueText, templatePreviewValuesKey };

package/dist/prosemirror/plugins/templatePreviewValues.js

@@ -1,6 +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";
 //#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("");
@@ -11,6 +12,20 @@ const templatePreviewValueFingerprint = (value) => {
 	if (typeof value === "string") return value;
 	return value.runs.map((run) => `${run.bold === true ? "b" : ""}${run.italic === true ? "i" : ""}:${run.text}`).join("\0");
 };
+/**
+* Whether a hidden span swallows a block whole, i.e. covers every position of
+* its content, leaving it nothing to render. `pmStart`/`pmEnd` are the block
+* node's own positions, so its content is `[pmStart + 1, pmEnd - 1)`.
+*
+* The decoration path and the paged flow both drop a block on this predicate,
+* so the two surfaces hide exactly the same blocks; a block only partly covered
+* fails it and keeps its text, and the covered span alone is hidden.
+*/
+const templatePreviewHidesWholeBlock = (range, block) => range.from <= block.pmStart + 1 && range.to >= block.pmEnd - 1;
+/** Hides the marker text a preview value stands in for. */
+const ORIGINAL_CLASS = "folio-template-preview-original";
+/** Hides a conditional block the host reported as not applying. */
+const HIDDEN_CLASS = "folio-template-preview-hidden";
 const KEY_HOLDER_SYMBOL = Symbol.for("stll.folio.templatePreviewValuesKey");
 const keyHolder = globalThis;
 const templatePreviewValuesKey = keyHolder[KEY_HOLDER_SYMBOL] ?? (keyHolder[KEY_HOLDER_SYMBOL] = new PluginKey("templatePreviewValues"));
@@ -29,6 +44,13 @@ function buildSpanNode(span) {
 	}
 	return node;
 }
+/**
+* The widget standing in for a marker. A value carrying newlines breaks its
+* lines inside the paragraph, not into new ones: here through the widget class's
+* `white-space: pre-wrap`, and on the paged canvas through the line break runs
+* `applyTemplatePreviewToBlocks` emits. The two must keep agreeing — an inline
+* `{{ path }}` placeholder cannot introduce paragraphs on either surface.
+*/
 function buildValueWidget(value, mode) {
 	return () => {
 		const span = document.createElement("span");
@@ -42,13 +64,142 @@ function buildValueWidget(value, mode) {
 		return span;
 	};
 }
-function collectPreviewEntries(doc, preview) {
-	if (!preview || Object.keys(preview.values).length === 0) return [];
+/** 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.
+*
+* 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.
+*/
+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;
+};
+/**
+* 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
+* host's prototype carries) and a value from an untyped host are read as
+* silence rather than as a verdict.
+*/
+const ownVerdict = (conditions, key) => {
+	if (!Object.hasOwn(conditions, key)) return;
+	const value = conditions[key];
+	return typeof value === "boolean" ? value : void 0;
+};
+/**
+* The host's verdict on one condition: keyed by the expression as written, else
+* 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);
+	if (exact !== void 0) return exact;
+	const path = filterChainPath(expr);
+	return path === void 0 ? void 0 : ownVerdict(conditions, path);
+};
+/**
+* The spans the host's verdicts hide, in document order and without their
+* nested hidden blocks: hiding a block already hides everything inside it.
+*
+* A `false` block is hidden whole, opener through closer. A `true` block keeps
+* its body, and in `plain` mode loses its tag paragraphs — opener, any
+* `{% elif %}` / `{% else %}`, closer — so the reader sees the document as it
+* will be generated rather than its scaffolding. `highlighted` mode exists to
+* show that scaffolding, so it keeps the tags. A block no verdict mentions is
+* left exactly as authored.
+*
+* Openers and closers pair off a kind-aware stack — `{% endif %}` closes the
+* nearest open `{% if %}`, `{% endfor %}` the nearest `{% for %}` — so a
+* mid-edit template with an unpaired opener or a stray closer hides nothing
+* rather than guessing a span. Inline markers pair like block ones: the fill
+* engine resolves an inline conditional within its paragraph, so the preview
+* follows. An `{% elif %}` or `{% else %}` branch of a `false` block sits
+* inside its span and is hidden with it.
+*/
+function collectHiddenRanges(ranges, conditions, mode) {
+	if (conditions === void 0) return [];
+	const open = [];
+	const paired = [];
+	for (const range of [...ranges].sort((a, b) => a.from - b.from)) {
+		if (range.kind === "if" || range.kind === "for") {
+			open.push({
+				opener: range,
+				branches: []
+			});
+			continue;
+		}
+		if (range.kind === "elif" || range.kind === "else") {
+			const innermost = open.at(-1);
+			if (innermost?.opener.kind === "if") innermost.branches.push(range);
+			continue;
+		}
+		if (range.kind !== "endif" && range.kind !== "endfor") continue;
+		const wanted = range.kind === "endif" ? "if" : "for";
+		let block;
+		for (let index = open.length - 1; index >= 0; index -= 1) {
+			const candidate = open[index];
+			if (candidate?.opener.kind === wanted) {
+				block = candidate;
+				open.length = index;
+				break;
+			}
+		}
+		if (block === void 0 || block.opener.kind !== "if") continue;
+		const { opener, branches } = block;
+		const verdict = conditionVerdict(conditions, opener.expr);
+		if (verdict === void 0) continue;
+		if (!verdict) {
+			paired.push({
+				from: opener.from,
+				to: range.to,
+				expr: opener.expr
+			});
+			continue;
+		}
+		if (mode !== "plain") continue;
+		paired.push({
+			from: opener.from,
+			to: opener.to,
+			expr: opener.expr
+		});
+		for (const branch of branches) paired.push({
+			from: branch.from,
+			to: branch.to,
+			expr: opener.expr
+		});
+		paired.push({
+			from: range.from,
+			to: range.to,
+			expr: opener.expr
+		});
+	}
+	paired.sort((a, b) => a.from - b.from || b.to - a.to);
+	const outermost = [];
+	for (const range of paired) {
+		const previous = outermost.at(-1);
+		if (previous && range.to <= previous.to) continue;
+		outermost.push(range);
+	}
+	return outermost;
+}
+function collectPreviewEntries(ranges, values, hidden) {
 	const entries = [];
-	for (const range of scanDirectives(doc)) {
+	for (const range of ranges) {
 		if (range.kind !== "placeholder" && range.kind !== "clause") continue;
-		const value = preview.values[range.expr];
+		const value = values[range.expr];
 		if (value === void 0 || templatePreviewValueText(value) === "") continue;
+		if (hidden.some((block) => range.from >= block.from && range.from < block.to)) continue;
 		entries.push({
 			from: range.from,
 			to: range.to,
@@ -58,10 +209,59 @@ function collectPreviewEntries(doc, preview) {
 	}
 	return entries;
 }
-function buildDecorationSet(doc, entries, mode) {
-	if (entries.length === 0) return DecorationSet.empty;
+function projectPreview(doc, preview) {
+	if (!preview) return {
+		entries: [],
+		hidden: []
+	};
+	const hasValues = Object.keys(preview.values).length > 0;
+	const hasConditions = preview.conditions !== void 0 && Object.keys(preview.conditions).length > 0;
+	if (!hasValues && !hasConditions) return {
+		entries: [],
+		hidden: []
+	};
+	const ranges = scanDirectives(doc);
+	const hidden = collectHiddenRanges(ranges, preview.conditions, preview.mode);
+	return {
+		entries: hasValues ? collectPreviewEntries(ranges, preview.values, hidden) : [],
+		hidden
+	};
+}
+/**
+* Hide one span: a block the span covers whole is hidden as a node, leaving no
+* empty line behind; a block it covers in part is hidden over the covered text
+* only, so an inline `{% if %}` in a paragraph of running text takes its own
+* span and nothing else.
+*/
+function pushHiddenDecorations(doc, range, out) {
+	const { from, to } = range;
+	doc.nodesBetween(from, to, (node, pos) => {
+		if (!node.isBlock) return false;
+		const nodeEnd = pos + node.nodeSize;
+		if (templatePreviewHidesWholeBlock(range, {
+			pmStart: pos,
+			pmEnd: nodeEnd
+		})) {
+			out.push(Decoration.node(pos, nodeEnd, { class: HIDDEN_CLASS }));
+			return false;
+		}
+		const contentFrom = pos + 1;
+		const contentTo = nodeEnd - 1;
+		if (!node.isTextblock) return true;
+		const spanFrom = Math.max(from, contentFrom);
+		const spanTo = Math.min(to, contentTo);
+		if (spanTo > spanFrom) out.push(Decoration.inline(spanFrom, spanTo, { class: HIDDEN_CLASS }, {
+			inclusiveStart: false,
+			inclusiveEnd: false
+		}));
+		return false;
+	});
+}
+function buildDecorationSet(doc, { entries, hidden }, mode) {
+	if (entries.length === 0 && hidden.length === 0) return DecorationSet.empty;
 	const decorations = [];
-	for (const entry of entries) decorations.push(Decoration.inline(entry.from, entry.to, { class: "folio-template-preview-original" }, {
+	for (const range of hidden) pushHiddenDecorations(doc, range, decorations);
+	for (const entry of entries) decorations.push(Decoration.inline(entry.from, entry.to, { class: ORIGINAL_CLASS }, {
 		inclusiveStart: false,
 		inclusiveEnd: false
 	}), Decoration.widget(entry.from, buildValueWidget(entry.value, mode), {
@@ -80,25 +280,28 @@ function createTemplatePreviewValuesPlugin() {
 				return {
 					preview: null,
 					entries: [],
+					hidden: [],
 					decorationSet: DecorationSet.empty
 				};
 			},
 			apply(tr, prev, _oldState, newState) {
 				const meta = tr.getMeta(templatePreviewValuesKey);
 				if (meta !== void 0) {
-					const entries = collectPreviewEntries(newState.doc, meta.preview);
+					const projection = projectPreview(newState.doc, meta.preview);
 					return {
 						preview: meta.preview,
-						entries,
-						decorationSet: buildDecorationSet(newState.doc, entries, meta.preview?.mode ?? "plain")
+						entries: projection.entries,
+						hidden: projection.hidden,
+						decorationSet: buildDecorationSet(newState.doc, projection, meta.preview?.mode ?? "plain")
 					};
 				}
 				if (tr.docChanged && prev.preview) {
-					const entries = collectPreviewEntries(newState.doc, prev.preview);
+					const projection = projectPreview(newState.doc, prev.preview);
 					return {
 						preview: prev.preview,
-						entries,
-						decorationSet: buildDecorationSet(newState.doc, entries, prev.preview.mode)
+						entries: projection.entries,
+						hidden: projection.hidden,
+						decorationSet: buildDecorationSet(newState.doc, projection, prev.preview.mode)
 					};
 				}
 				return prev;
@@ -114,4 +317,4 @@ const setTemplatePreviewValues = (view, preview) => {
 	view.dispatch(view.state.tr.setMeta(templatePreviewValuesKey, { preview }));
 };
 //#endregion
-export { createTemplatePreviewValuesPlugin, setTemplatePreviewValues, templatePreviewValueFingerprint, templatePreviewValueText, templatePreviewValuesKey };
+export { createTemplatePreviewValuesPlugin, setTemplatePreviewValues, templatePreviewHidesWholeBlock, templatePreviewValueFingerprint, templatePreviewValueText, templatePreviewValuesKey };

package/dist/prosemirror/styles/resolvedStyleAttrs.js

@@ -1,4 +1,5 @@
 import { computeListRendering, numberingLevelHasMarkerSlot } from "../../docx/numberingParser.js";
+import { isNumberingReference } from "../../docx/numberingReference.js";
 import { tableOfContentsStyleLevel } from "../../utils/tableOfContentsStyle.js";
 import { setAutospacingBaseValue } from "../autospacingBase.js";
 import { CLEARED_LIST_RENDERING_ATTRS } from "../listMarker.js";
@@ -74,7 +75,7 @@ function autospacingBaseFromResolvedParagraphFormatting(ppr) {
 */
 function listAttrsFromResolvedStyle(resolved, numbering) {
 	const numPr = resolved.paragraphFormatting?.numPr;
-	if (!numPr || numPr.numId === void 0 || numPr.numId === 0) return null;
+	if (!numPr || !isNumberingReference(numPr.numId)) return null;
 	const attrs = listAttrsFromNumbering({
 		numId: numPr.numId,
 		ilvl: numPr.ilvl ?? 0

package/dist/prosemirror/styles/styleResolver.js

@@ -1,3 +1,4 @@
+import { BUILT_IN_DEFAULT_PARAGRAPH_FORMATTING, resolveDefaultParagraphStyle } from "../../docx/defaultParagraphStyle.js";
 import { mergeParagraphFormatting } from "../../utils/paragraphFormattingMerge.js";
 import { cascadeStyleTextFormatting } from "./styleToggleCascade.js";
 //#region src/prosemirror/styles/styleResolver.ts
@@ -19,11 +20,7 @@ const BUILTIN_NORMAL_STYLE = {
 	type: "paragraph",
 	name: "Normal",
 	default: true,
-	pPr: {
-		spaceAfter: 160,
-		lineSpacing: 259,
-		lineSpacingRule: "auto"
-	}
+	pPr: BUILT_IN_DEFAULT_PARAGRAPH_FORMATTING
 };
 /**
 * StyleResolver provides efficient access to resolved style properties
@@ -213,8 +210,8 @@ var StyleResolver = class {
 		return this.stylesById.has(styleId);
 	}
 	findDefaultStyle(type) {
+		if (type === "paragraph") return resolveDefaultParagraphStyle(this.stylesById.values()) ?? (this.docDefaults ? void 0 : BUILTIN_NORMAL_STYLE);
 		for (const style of this.stylesById.values()) if (style.type === type && style.default) return style;
-		if (type === "paragraph") return this.stylesById.get("Normal") ?? (this.docDefaults ? void 0 : BUILTIN_NORMAL_STYLE);
 	}
 };
 /**

package/dist/prosemirror/utils/visualLineNavigation.d.ts

@@ -1,9 +1,29 @@
 import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/utils/visualLineNavigation.d.ts
+/**
+ * Where the previous vertical step left the caret: the column later steps keep
+ * (`stickyX`), the visual line it settled on, and the caret position both
+ * describe. The line index is not redundant with the position — a soft-wrap
+ * boundary position belongs to two visual lines (the end of the wrapped line
+ * and the start of the next), so the painted DOM alone cannot say which one the
+ * caret sits on.
+ *
+ * @internal
+ */
+type VisualLineStep = {
+  stickyX: number;
+  lineIndex: number;
+  pmPos: number;
+};
 /** @internal */
 type VisualLineState = {
-  stickyX: number | null;
-  lastVisualLineIndex: number;
+  /**
+   * Only describes the caret while it is still at `step.pmPos`. Any other move
+   * (a click, a find result, an agent edit, typing) leaves the caret elsewhere,
+   * and the next vertical step re-resolves both column and line from the DOM
+   * instead of continuing from a line the caret has left.
+   */
+  step: VisualLineStep | null;
 };
 /** @internal */
 declare function createVisualLineState(): VisualLineState;