pa_font 0.3.2 → 0.3.4

package/dist/paFont.js

@@ -3317,28 +3317,28 @@ function layoutParagraph(fontInstance, text, options = {}, state = {}) {
 	const textBBox = combineRects(lines.map((line) => line.bbox)) ?? emptyRect();
 	const textWidth = lines.reduce((max, line) => Math.max(max, line.width), 0);
 	const textHeight = resolvePositionedTextHeight(lines, layoutBox.contentY);
-	const finalLayoutBox = finalizeLayoutBox(layoutBox, normalized, textHeight);
+	const anchoredLayout = applyParagraphAnchor(lines, textBBox, finalizeLayoutBox(layoutBox, normalized, textHeight), normalized.anchor);
 	const cachedPrepared = pretextState?.prepared ?? retainedPreparedState.prepared ?? null;
 	const cachedPreparedWhiteSpace = pretextState?.preparedWhiteSpace ?? retainedPreparedState.preparedWhiteSpace ?? null;
 	return {
 		options: normalized,
-		lines,
+		lines: anchoredLayout.lines,
 		metrics: {
-			x: finalLayoutBox.contentBox.x,
-			y: finalLayoutBox.contentBox.y,
+			x: anchoredLayout.layoutBox.contentBox.x,
+			y: anchoredLayout.layoutBox.contentBox.y,
 			width: textWidth,
 			height: textHeight,
 			lineCount: lines.length,
-			bbox: textBBox,
-			contentBox: { ...finalLayoutBox.contentBox },
-			paddingBox: { ...finalLayoutBox.paddingBox },
-			marginBox: { ...finalLayoutBox.marginBox },
-			clipBox: { ...finalLayoutBox.clipBox }
+			bbox: anchoredLayout.textBBox,
+			contentBox: { ...anchoredLayout.layoutBox.contentBox },
+			paddingBox: { ...anchoredLayout.layoutBox.paddingBox },
+			marginBox: { ...anchoredLayout.layoutBox.marginBox },
+			clipBox: { ...anchoredLayout.layoutBox.clipBox }
 		},
 		prepared: cachedPrepared,
 		preparedWhiteSpace: cachedPreparedWhiteSpace,
 		layoutEngine: layoutState.layoutEngine,
-		layoutBox: finalLayoutBox,
+		layoutBox: anchoredLayout.layoutBox,
 		containerWidth: layoutBox.containerWidth,
 		containerHeight: layoutBox.containerHeight
 	};
@@ -3354,9 +3354,11 @@ function normalizeParagraphOptions(fontInstance, options = {}) {
 	const width = normalizeDimension(options.width);
 	const height = normalizeDimension(options.height);
 	const gap = normalizeGap(options.gap);
+	const anchor = normalizeAnchor(options.anchor);
 	if (options.width != null && width == null) throw new TypeError("font.paragraph() option \"width\" must be a positive number.");
 	if (options.height != null && height == null) throw new TypeError("font.paragraph() option \"height\" must be a positive number.");
 	if (options.gap != null && gap == null) throw new TypeError("font.paragraph() option \"gap\" must be a non-negative number.");
+	if (options.anchor != null && anchor == null) throw new TypeError("font.paragraph() option \"anchor\" must be a number, [x, y], or { x, y }.");
 	const font = resolveCanvasFont(fontInstance, textOptions.size, options);
 	return {
 		...textOptions,
@@ -3372,6 +3374,7 @@ function normalizeParagraphOptions(fontInstance, options = {}) {
 		width,
 		height,
 		gap: gap ?? DEFAULT_PARAGRAPH_GAP,
+		anchor,
 		lineHeight: resolveLineHeight(options.lineHeight, textOptions.size),
 		align: normalizeEnum(options.align, [
 			"left",
@@ -3812,6 +3815,44 @@ function finalizeLayoutBox(layoutBox, options, textHeight) {
 		}
 	};
 }
+function applyParagraphAnchor(lines, textBBox, layoutBox, anchor) {
+	if (anchor == null) return {
+		lines,
+		textBBox,
+		layoutBox
+	};
+	const tx = layoutBox.contentX - (textBBox.x + textBBox.w * anchor.x);
+	const ty = layoutBox.contentY - (textBBox.y + textBBox.h * anchor.y);
+	return {
+		lines: translatePositionedLines(lines, tx, ty),
+		textBBox: translateRect(textBBox, tx, ty),
+		layoutBox: translateLayoutBox(layoutBox, tx, ty)
+	};
+}
+function translatePositionedLines(lines, tx, ty) {
+	return lines.map((line) => ({
+		...line,
+		x: line.x + tx,
+		y: line.y + ty,
+		baseline: line.baseline + ty,
+		bbox: translateRect(line.bbox, tx, ty),
+		fragments: line.fragments.map((fragment) => ({
+			...fragment,
+			x: fragment.x + tx
+		}))
+	}));
+}
+function translateLayoutBox(layoutBox, tx, ty) {
+	return {
+		...layoutBox,
+		contentX: layoutBox.contentX + tx,
+		contentY: layoutBox.contentY + ty,
+		contentBox: translateRect(layoutBox.contentBox, tx, ty),
+		paddingBox: translateRect(layoutBox.paddingBox, tx, ty),
+		marginBox: translateRect(layoutBox.marginBox, tx, ty),
+		clipBox: translateRect(layoutBox.clipBox, tx, ty)
+	};
+}
 function resolveContainerDimension(explicit, fallback) {
 	if (Number.isFinite(explicit) && explicit > 0) return explicit;
 	if (Number.isFinite(fallback) && fallback > 0) return fallback;
@@ -3840,6 +3881,40 @@ function normalizeDimension(value) {
 function normalizeGap(value) {
 	return Number.isFinite(value) && value >= 0 ? Number(value) : null;
 }
+function normalizeAnchor(value) {
+	if (value == null) return null;
+	if (Number.isFinite(value)) {
+		const next = Number(value);
+		return {
+			x: next,
+			y: next
+		};
+	}
+	if (Array.isArray(value)) {
+		if (value.length === 1 && Number.isFinite(value[0])) {
+			const next = Number(value[0]);
+			return {
+				x: next,
+				y: next
+			};
+		}
+		if (value.length >= 2 && Number.isFinite(value[0]) && Number.isFinite(value[1])) return {
+			x: Number(value[0]),
+			y: Number(value[1])
+		};
+		return null;
+	}
+	if (typeof value === "object") {
+		const hasX = Number.isFinite(value.x);
+		const hasY = Number.isFinite(value.y);
+		if (!hasX && !hasY) return null;
+		return {
+			x: hasX ? Number(value.x) : 0,
+			y: hasY ? Number(value.y) : 0
+		};
+	}
+	return null;
+}
 function normalizeSpacing(value) {
 	if (value == null) return zeroSpacing();
 	if (Number.isFinite(value)) {