@embedpdf/core-annotation 3.0.0-next.11 → 3.0.0-next.13

package/dist/index.cjs

@@ -207,6 +207,18 @@ const TEXT_PROPS = [
 		key: "fontColor",
 		label: "Text color"
 	},
+	{
+		key: "bold",
+		label: "Bold"
+	},
+	{
+		key: "italic",
+		label: "Italic"
+	},
+	{
+		key: "underline",
+		label: "Underline"
+	},
 	{
 		key: "textAlign",
 		label: "Align"
@@ -2687,41 +2699,60 @@ function geomDragHandle(g, handle, to) {
 	}
 	return g;
 }
+/**
+* The text PLATE inset of a free-text box: twice the border width. The plate
+* — where text lays out, clips and scrolls — is the box deflated by this on
+* every side: the ink band and an equal breathing band, so the text never
+* touches the stroke. Acrobat's rule, measured 1–12 pt on plain boxes and
+* 1–7 pt on callouts (plan `2026-09-15-free-text-plate-inset.md`); the
+* engine's `FreeTextPlate` is the same formula, so the live editor sits
+* exactly where the baked text lands. Acrobat's thinnest border is 1 pt; a
+* width of 0 is ours alone and gives no inset (the plate is the box).
+*/
+function textPlateInset(strokeWidth) {
+	return 2 * Math.max(0, strokeWidth);
+}
+/** A callout's leader (open polyline, its connection point extended under
+*  the box border by half the stroke — the AP generator's `adjusted_conn` —
+*  so the leader meets the border ink without an angular gap) + the arrow at
+*  its tip. */
+function calloutLeaderNodes(g, callout, strokeWidth) {
+	const pts = [...calloutLinePoints(g)];
+	if (strokeWidth > 0 && pts.length >= 2) {
+		const last = pts[pts.length - 1];
+		const prev = pts[pts.length - 2];
+		const dx = last.x - prev.x;
+		const dy = last.y - prev.y;
+		const len = Math.hypot(dx, dy);
+		if (len > 0) pts[pts.length - 1] = {
+			x: last.x + dx / len * (strokeWidth / 2),
+			y: last.y + dy / len * (strokeWidth / 2)
+		};
+	}
+	const nodes = [{
+		kind: "poly",
+		points: pts,
+		closed: false
+	}];
+	const seg = calloutEndingSeg(pts, callout.ending);
+	if (seg) nodes.push(...endingNodes(seg.tip, seg.angle, seg.ending, strokeWidth));
+	return nodes;
+}
 function geomScene(g, strokeWidth = 0, border) {
 	if (g.t === "text") {
-		if (!g.callout) return [];
-		const pts = [...calloutLinePoints(g)];
-		if (strokeWidth > 0 && pts.length >= 2) {
-			const last = pts[pts.length - 1];
-			const prev = pts[pts.length - 2];
-			const dx = last.x - prev.x;
-			const dy = last.y - prev.y;
-			const len = Math.hypot(dx, dy);
-			if (len > 0) pts[pts.length - 1] = {
-				x: last.x + dx / len * (strokeWidth / 2),
-				y: last.y + dy / len * (strokeWidth / 2)
-			};
-		}
-		const nodes = [{
+		const nodes = [];
+		if (g.callout) nodes.push(...calloutLeaderNodes(g, g.callout, strokeWidth));
+		const r = insetRect(g.rect, strokeWidth / 2);
+		const rot = g.rot ?? 0;
+		const c = rectCenter(g.rect);
+		nodes.push(rot ? {
 			kind: "poly",
-			points: pts,
-			closed: false
-		}];
-		const seg = calloutEndingSeg(pts, g.callout.ending);
-		if (seg) nodes.push(...endingNodes(seg.tip, seg.angle, seg.ending, strokeWidth));
-		if (strokeWidth > 0) {
-			const r = insetRect(g.rect, strokeWidth / 2);
-			const rot = g.rot ?? 0;
-			const c = rectCenter(g.rect);
-			nodes.push(rot ? {
-				kind: "poly",
-				points: rectCornerPoints(r).map((p) => rotatePoint(p, c, rot)),
-				closed: true
-			} : {
-				kind: "rect",
-				rect: r
-			});
-		}
+			points: rectCornerPoints(r).map((p) => rotatePoint(p, c, rot)),
+			closed: true
+		} : {
+			kind: "rect",
+			rect: r
+		});
 		return nodes;
 	}
 	if (g.t === "caret") {
@@ -3227,7 +3258,10 @@ const textStyleFromProps = (p) => ({
 	fontFamily: p.fontFamily,
 	fontSize: p.fontSize,
 	fontColor: p.fontColor,
-	textAlign: p.textAlign
+	textAlign: p.textAlign,
+	...p.bold !== void 0 ? { bold: p.bold } : {},
+	...p.italic !== void 0 ? { italic: p.italic } : {},
+	...p.underline !== void 0 ? { underline: p.underline } : {}
 });
 /** Does this kind's prop table declare `link` (attachable link)? The link
 *  KIND itself also declares it, but stores its own `/A` instead. */
@@ -3253,6 +3287,9 @@ function readProp(a, key) {
 			case "fontSize": return a.text?.fontSize;
 			case "fontColor": return a.text?.fontColor;
 			case "textAlign": return a.text?.textAlign;
+			case "bold": return a.text ? a.text.bold ?? false : void 0;
+			case "italic": return a.text ? a.text.italic ?? false : void 0;
+			case "underline": return a.text ? a.text.underline ?? false : void 0;
 			case "icon": return a.icon;
 			case "link": return a.link;
 		}
@@ -3340,6 +3377,17 @@ function applyProps(a, patch) {
 			text.textAlign = patch.textAlign;
 			textChanged = true;
 		}
+		for (const key of [
+			"bold",
+			"italic",
+			"underline"
+		]) {
+			const value = patch[key];
+			if (value !== void 0 && takes.has(key) && (text[key] ?? false) !== value) {
+				text[key] = value;
+				textChanged = true;
+			}
+		}
 		if (textChanged) next = {
 			...next,
 			text
@@ -3469,6 +3517,236 @@ function clickCreateGeom(subtype, placement, def) {
 	return null;
 }
 //#endregion
+//#region src/richtext.ts
+/** Length of the plain projection. */
+function richTextLength(doc) {
+	let n = 0;
+	doc.paragraphs.forEach((p, i) => {
+		if (i > 0) n += 1;
+		for (const r of p.runs) n += r.text.length;
+	});
+	return n;
+}
+const DELTA_KEYS = [
+	"family",
+	"weight",
+	"italic",
+	"size",
+	"color",
+	"decoration",
+	"script",
+	"letterSpacing",
+	"horizontalScale",
+	"unknown"
+];
+function sameDecoration(a, b) {
+	if (a === b) return true;
+	if (!a || !b || a.length !== b.length) return false;
+	const sorted = (x) => [...x].sort();
+	const sa = sorted(a);
+	const sb = sorted(b);
+	return sa.every((v, i) => v === sb[i]);
+}
+/** Two deltas override the same properties with the same values. */
+function sameStyleDelta(a, b) {
+	const da = a ?? {};
+	const db = b ?? {};
+	for (const key of DELTA_KEYS) if (key === "decoration") {
+		if (!sameDecoration(da.decoration, db.decoration)) return false;
+	} else if (da[key] !== db[key]) return false;
+	return true;
+}
+/** A delta with every `undefined` member removed; `undefined` when empty. */
+function cleanDelta(delta) {
+	if (!delta) return void 0;
+	const out = {};
+	let any = false;
+	for (const key of DELTA_KEYS) {
+		const value = delta[key];
+		if (value !== void 0) {
+			out[key] = value;
+			any = true;
+		}
+	}
+	return any ? out : void 0;
+}
+/**
+* Merge adjacent runs whose deltas agree, drop empty runs, strip empty
+* deltas. A paragraph with no text keeps a single empty run so the editor
+* has somewhere to put the caret.
+*/
+function normalizeRuns(doc) {
+	const paragraphs = doc.paragraphs.map((p) => {
+		const runs = [];
+		for (const run of p.runs) {
+			if (run.text.length === 0) continue;
+			const style = cleanDelta(run.style);
+			const last = runs[runs.length - 1];
+			if (last && sameStyleDelta(last.style, style)) runs[runs.length - 1] = {
+				...last,
+				text: last.text + run.text
+			};
+			else runs.push(style ? {
+				text: run.text,
+				style
+			} : { text: run.text });
+		}
+		if (runs.length === 0) runs.push({ text: "" });
+		return {
+			...p,
+			runs
+		};
+	});
+	return {
+		...doc,
+		paragraphs
+	};
+}
+/** Where a flat offset falls: paragraph index and offset within it (the
+*  separator between paragraphs belongs to the end of the earlier one). */
+function locateOffset(doc, offset) {
+	let pos = 0;
+	for (let i = 0; i < doc.paragraphs.length; i++) {
+		const length = doc.paragraphs[i].runs.reduce((n, r) => n + r.text.length, 0);
+		if (offset <= pos + length || i === doc.paragraphs.length - 1) return {
+			paragraph: i,
+			offset: Math.max(0, Math.min(length, offset - pos))
+		};
+		pos += length + 1;
+	}
+	return {
+		paragraph: 0,
+		offset: 0
+	};
+}
+/** The paragraph with a run boundary guaranteed at a local offset. */
+function splitRunsAt(paragraph, offset) {
+	const runs = [];
+	let pos = 0;
+	for (const run of paragraph.runs) {
+		const end = pos + run.text.length;
+		if (offset > pos && offset < end) {
+			const cut = offset - pos;
+			runs.push({
+				...run,
+				text: run.text.slice(0, cut)
+			});
+			runs.push({
+				...run,
+				text: run.text.slice(cut)
+			});
+		} else runs.push(run);
+		pos = end;
+	}
+	return {
+		...paragraph,
+		runs
+	};
+}
+/**
+* Apply a style delta to every character of a range: the runs it touches are
+* split at its boundaries, the covered pieces take the delta on top of what
+* they already override (`clear` names properties to stop overriding, so
+* they follow the body again), and the result is normalised. An empty range
+* is a no-op.
+*/
+function applyStyleToRange(doc, range, delta, clear = []) {
+	const start = Math.max(0, Math.min(range.start, range.end));
+	const end = Math.max(range.start, range.end);
+	if (end <= start) return doc;
+	const from = locateOffset(doc, start);
+	const to = locateOffset(doc, end);
+	const paragraphs = doc.paragraphs.map((paragraph, index) => {
+		if (index < from.paragraph || index > to.paragraph) return paragraph;
+		const localStart = index === from.paragraph ? from.offset : 0;
+		const localEnd = index === to.paragraph ? to.offset : paragraph.runs.reduce((n, r) => n + r.text.length, 0);
+		if (localEnd <= localStart) return paragraph;
+		const split = splitRunsAt(splitRunsAt(paragraph, localStart), localEnd);
+		let pos = 0;
+		const runs = split.runs.map((run) => {
+			const runStart = pos;
+			pos += run.text.length;
+			if (runStart < localStart || runStart >= localEnd || run.text.length === 0) return run;
+			const style = {
+				...run.style ?? {},
+				...delta
+			};
+			for (const key of clear) delete style[key];
+			return {
+				...run,
+				style
+			};
+		});
+		return {
+			...split,
+			runs
+		};
+	});
+	return normalizeRuns({
+		...doc,
+		paragraphs
+	});
+}
+/**
+* The delta in force at a caret: the run the offset falls in, or, at a run
+* boundary, the run before it (what typing there would inherit). Undefined
+* for an empty document.
+*/
+function styleAt(doc, offset) {
+	const at = locateOffset(doc, offset);
+	const paragraph = doc.paragraphs[at.paragraph];
+	if (!paragraph) return void 0;
+	let pos = 0;
+	let previous;
+	for (const run of paragraph.runs) {
+		const end = pos + run.text.length;
+		if (at.offset > pos && at.offset <= end) return run.style ?? {};
+		if (at.offset === pos && pos === 0) return run.style ?? {};
+		previous = run;
+		pos = end;
+	}
+	return previous?.style ?? {};
+}
+/** Every run overlapping the range satisfies `predicate` (an empty range
+*  tests the caret's style). */
+function rangeHasStyle(doc, range, predicate) {
+	const start = Math.min(range.start, range.end);
+	const end = Math.max(range.start, range.end);
+	if (end <= start) return predicate(styleAt(doc, start) ?? {});
+	const from = locateOffset(doc, start);
+	const to = locateOffset(doc, end);
+	let any = false;
+	for (let index = from.paragraph; index <= to.paragraph; index++) {
+		const paragraph = doc.paragraphs[index];
+		const localStart = index === from.paragraph ? from.offset : 0;
+		const localEnd = index === to.paragraph ? to.offset : paragraph.runs.reduce((n, r) => n + r.text.length, 0);
+		let pos = 0;
+		for (const run of paragraph.runs) {
+			const runEnd = pos + run.text.length;
+			if (runEnd > localStart && pos < localEnd && run.text.length > 0) {
+				any = true;
+				if (!predicate(run.style ?? {})) return false;
+			}
+			pos = runEnd;
+		}
+	}
+	return any;
+}
+/** Plain paragraphs from text: one per line break, one unstyled run each. */
+function paragraphsFromPlainText(text) {
+	return text.split(/\r\n|\r|\n/).map((line) => ({ runs: [{ text: line }] }));
+}
+/** The plain projection: paragraphs joined by `\r`, runs concatenated. */
+function plainTextOf(doc) {
+	return doc.paragraphs.map((p) => p.runs.map((r) => r.text).join("")).join("\r");
+}
+/** True when nothing in the document overrides the body: no run delta, no
+*  paragraph property. Such a document commits as plain `contents`. */
+function isPlainRichText(doc) {
+	if (doc.body && Object.keys(doc.body).length > 0) return false;
+	return doc.paragraphs.every((p) => p.align === void 0 && p.dir === void 0 && p.lineHeight === void 0 && p.margins === void 0 && p.textIndent === void 0 && p.unknown === void 0 && p.runs.every((r) => cleanDelta(r.style) === void 0));
+}
+//#endregion
 //#region src/snap.ts
 /**
 * Pure alignment snapping for the move gesture. Compares the moving selection's
@@ -3902,6 +4180,7 @@ function update(m, msg) {
 			draft: null
 		}, []] : [m, []];
 		case "setText": return setText(m, msg.id, msg.text);
+		case "setRichText": return setRichText(m, msg.id, msg.doc);
 		case "endTextEdit": return m.editing ? [{
 			...m,
 			editing: null
@@ -3915,12 +4194,49 @@ function update(m, msg) {
 function setText(m, id, text) {
 	const a = m.byId[id];
 	if (!a) return [m, []];
+	const data = a.data && a.data.subtype === "free-text" ? {
+		...a.data,
+		contents: text,
+		richText: {
+			...a.data.richText,
+			paragraphs: paragraphsFromPlainText(text)
+		}
+	} : a.data ? {
+		...a.data,
+		contents: text
+	} : a.data;
+	const next = toVector({
+		...a,
+		data
+	});
+	return [{
+		...m,
+		byId: {
+			...m.byId,
+			[id]: next
+		}
+	}, []];
+}
+/** Apply the editor's rich document optimistically. The DTO's body is kept
+*  (a partial input body layers on it); `contents` is the projection. */
+function setRichText(m, id, doc) {
+	const a = m.byId[id];
+	if (!a || !a.data || a.data.subtype !== "free-text") return [m, []];
+	const normalized = normalizeRuns(doc);
+	const richText = {
+		body: {
+			...a.data.richText.body,
+			...normalized.body ?? {}
+		},
+		paragraphs: normalized.paragraphs
+	};
 	const next = toVector({
 		...a,
-		data: a.data ? {
+		data: {
 			...a.data,
-			contents: text
-		} : a.data
+			richText,
+			contents: plainTextOf(richText)
+		}
 	});
 	return [{
 		...m,
@@ -5522,7 +5838,7 @@ function effAp(m, id, view) {
 function effSource(m, id) {
 	const a = m.byId[id];
 	if (capsFor(a.subtype).opaqueBody) return a.source;
-	if (m.editing === id && a.geom.t === "text" && a.geom.callout) return "vector";
+	if (m.editing === id && a.geom.t === "text") return "vector";
 	const d = m.draft;
 	if (d?.g === "handle" && d.id === id) return "vector";
 	if ((d?.g === "rotate" || d?.g === "group") && d.ids.includes(id)) return "vector";
@@ -5538,7 +5854,6 @@ function pageItems(m, pon, view) {
 	const items = [];
 	for (const id of paintOrder(m, pon)) {
 		const a = m.byId[id];
-		if (a.geom.t === "text" && !a.geom.callout && textIsLive(m, id)) continue;
 		const geom = effGeom(m, id, view);
 		const style = effStyle(a, view);
 		const ap = effAp(m, id, view);
@@ -5933,6 +6248,7 @@ exports.annotDeletable = annotDeletable;
 exports.annotInteractive = annotInteractive;
 exports.annotTransformable = annotTransformable;
 exports.applyProps = applyProps;
+exports.applyStyleToRange = applyStyleToRange;
 exports.calloutConnection = calloutConnection;
 exports.calloutLinePoints = calloutLinePoints;
 exports.canMove = canMove;
@@ -5980,28 +6296,36 @@ exports.initialTextStyle = initialTextStyle;
 exports.interactive = interactive;
 exports.isAttachedLink = isAttachedLink;
 exports.isConversationOnly = isConversationOnly;
+exports.isPlainRichText = isPlainRichText;
 exports.isRotatableGeom = isRotatableGeom;
 exports.isSelectable = isSelectable;
 exports.isSubstrateOnly = isSubstrateOnly;
 exports.linkChildrenOf = linkChildrenOf;
 exports.linkOf = linkOf;
+exports.locateOffset = locateOffset;
 exports.mergeFlags = mergeFlags;
 exports.normalizeDeg = normalizeDeg;
+exports.normalizeRuns = normalizeRuns;
 exports.obbFromGeom = obbFromGeom;
 exports.pageItems = pageItems;
+exports.paragraphsFromPlainText = paragraphsFromPlainText;
 exports.pdfToContentPoint = pdfToContentPoint;
 exports.pdfToContentRect = pdfToContentRect;
 exports.placeRotateKnob = placeRotateKnob;
+exports.plainTextOf = plainTextOf;
 exports.pointInQuad = pointInQuad;
 exports.propsFor = propsFor;
 exports.quadIntersectsRect = quadIntersectsRect;
+exports.rangeHasStyle = rangeHasStyle;
 exports.readProp = readProp;
 exports.rectFromPoints = rectFromPoints;
 exports.resolveClickPlacement = resolveClickPlacement;
+exports.richTextLength = richTextLength;
 exports.rotateDraftDelta = rotateDraftDelta;
 exports.rotateKnob = rotateKnob;
 exports.rotatedAabb = rotatedAabb;
 exports.rotatedHandleCursor = rotatedHandleCursor;
+exports.sameStyleDelta = sameStyleDelta;
 exports.scene = scene;
 exports.selectedItems = selectedItems;
 exports.selectionAnchor = selectionAnchor;
@@ -6012,9 +6336,12 @@ exports.selectionKnob = selectionKnob;
 exports.selectionQuad = selectionQuad;
 exports.shapeRectFor = shapeRectFor;
 exports.sharedProps = sharedProps;
+exports.splitRunsAt = splitRunsAt;
 exports.straightenInkStroke = straightenInkStroke;
+exports.styleAt = styleAt;
 exports.styleFromProps = styleFromProps;
 exports.textBoxes = textBoxes;
+exports.textPlateInset = textPlateInset;
 exports.textStyleFromProps = textStyleFromProps;
 exports.transposedAboutCenter = transposedAboutCenter;
 exports.unanchoredGeom = unanchoredGeom;