@embedpdf/plugin-selection 3.0.0-next.3 → 3.0.0-next.4

package/dist/index.js

@@ -1,251 +1,81 @@
 import { createCapabilityToken, definePlugin } from "@embedpdf/core";
 import { InteractionToken } from "@embedpdf/plugin-interaction";
-import { applyRect, boundsOfRects, pageGeometry } from "@embedpdf/core-geometry";
+import { applyPoint, invert, pageGeometry, textQuadBounds } from "@embedpdf/core-geometry";
+import { buildPageTextLayout, expandTextRangeToLine, expandTextRangeToWord, textGlyphAt, textGlyphQuad, textSegmentsForRange } from "@embedpdf/engine-core/runtime";
 //#region src/geometry.ts
 /**
-* The pure selection geometry: engine text geometry (PDF user space, y-up) →
-* viewer content space (y-down), glyph hit-testing, word/line expansion, and the
-* line-merge. No DOM, no engine, no React.
+* The selection plugin's COORDINATE SEAM — and nothing else.
 *
-* The non-trivial bits are ports of battle-tested algorithms, adapted to v3's
-* content-space `Rect {x,y,width,height}`:
-*   - `glyphAt`     — PDFium `GetIndexAtPos` (exact tight box, then a tolerance pass).
-*   - `rectsForRange` — Chromium `pdfium_range.cc` `MergeAdjacentRects` (one rect per line).
-*   - `expandToWord/Line` — Chromium `OnMultipleClick` (double = word, triple = line).
-* The PDF↔content y-flip is the geometry package's `pageGeometry` (the one place
-* that math lives), never hand-rolled here.
+* Segmentation, hit-testing, and word/line expansion live in the canonical
+* engine-core text layout (`@embedpdf/engine-core` `text/layout`): a text
+* range has exactly one segmentation whether it came from a drag or a
+* search. This module only converts between the viewer's content space
+* (y-down, crop-relative) and the engine's PDF space (y-up) — pointer
+* points inward, canonical segments outward. The PDF↔content y-flip is the
+* geometry package's `pageGeometry` (the one place that math lives), never
+* hand-rolled here.
 */
-const FLAG_EMPTY = 2;
-const isBoundary = (flags) => (flags & 3) !== 0;
-const isEmpty = (flags) => (flags & FLAG_EMPTY) !== 0;
-const toContent = (m, b) => applyRect(m, {
-	x: b.left,
-	y: b.bottom,
-	width: b.right - b.left,
-	height: b.top - b.bottom
-});
 /**
-* Flatten a page's text geometry into content-space glyphs + runs. Rotation does
-* NOT enter here — the overlay rides the page's CSS rotation, so glyphs stay in
-* un-rotated content space (the crop-relative y-flip is the only conversion).
+* Build a page's selection geometry. Page display rotation does NOT enter
+* here — the overlay rides the page's CSS rotation, so content space stays
+* un-rotated (the crop-relative y-flip is the only conversion; zoom = 1,
+* the viewer's zoom is applied later by `PageTransform.pageToContent`).
 */
-function buildPageText(snapshot, crop, rotation, userUnit) {
+function buildSelectionPageGeometry(snapshot, crop, rotation, userUnit) {
 	const { pdfToContent } = pageGeometry({
 		crop,
 		rotation,
 		userUnit
 	}, 1);
-	const glyphs = [];
-	const runs = [];
-	for (const run of snapshot.runs) {
-		const start = glyphs.length;
-		for (const g of run.glyphs) glyphs.push({
-			loose: toContent(pdfToContent, g.looseBox),
-			tight: g.tightBox ? toContent(pdfToContent, g.tightBox) : void 0,
-			flags: g.flags
-		});
-		runs.push({
-			start,
-			count: run.glyphs.length,
-			rect: toContent(pdfToContent, run.rect),
-			fontSize: run.fontSize
-		});
-	}
 	return {
-		glyphs,
-		runs
+		layout: buildPageTextLayout(snapshot),
+		toContent: pdfToContent,
+		fromContent: invert(pdfToContent)
 	};
 }
-function avgGlyphHeight(text) {
-	let total = 0;
-	let count = 0;
-	for (const g of text.glyphs) {
-		if (isEmpty(g.flags)) continue;
-		total += g.loose.height;
-		count++;
-	}
-	return count === 0 ? 0 : total / count;
+/** A content-space pointer point in the layout's PDF space. */
+function contentPointToPdf(geom, p) {
+	return applyPoint(geom.fromContent, p);
 }
 /**
-* The glyph index at a content-space point, or null when nothing is near (so the
-* caller can show the pointer cursor off-text). PDFium `GetIndexAtPos`: exact
-* tight-box containment first, then a tolerance pass (closest by Manhattan
-* distance within `toleranceFactor × average glyph height`).
+* A canonical PDF quad in content space. Engine quads carry frame-geometric
+* slot semantics (`p1..p4` = upper-start, upper-end, lower-start,
+* lower-end) — a trusted producer, so the y-flip maps corners straight onto
+* their names; imported-annotation normalization does NOT apply here.
 */
-function glyphAt(text, p, toleranceFactor = 1.5) {
-	for (const run of text.runs) {
-		const r = run.rect;
-		if (p.x < r.x || p.x > r.x + r.width || p.y < r.y || p.y > r.y + r.height) continue;
-		for (let i = 0; i < run.count; i++) {
-			const b = text.glyphs[run.start + i].tight ?? text.glyphs[run.start + i].loose;
-			if (p.x >= b.x && p.x <= b.x + b.width && p.y >= b.y && p.y <= b.y + b.height) return run.start + i;
-		}
-	}
-	if (toleranceFactor <= 0) return null;
-	const half = avgGlyphHeight(text) * toleranceFactor / 2;
-	let best = -1;
-	let bestDist = Infinity;
-	for (const run of text.runs) {
-		const r = run.rect;
-		if (p.y < r.y - half || p.y > r.y + r.height + half || p.x < r.x - half || p.x > r.x + r.width + half) continue;
-		for (let i = 0; i < run.count; i++) {
-			const g = text.glyphs[run.start + i];
-			if (isEmpty(g.flags)) continue;
-			const b = g.tight ?? g.loose;
-			if (p.x < b.x - half || p.x > b.x + b.width + half || p.y < b.y - half || p.y > b.y + b.height + half) continue;
-			const dx = Math.min(Math.abs(p.x - b.x), Math.abs(p.x - (b.x + b.width)));
-			const dy = Math.min(Math.abs(p.y - b.y), Math.abs(p.y - (b.y + b.height)));
-			if (dx + dy < bestDist) {
-				bestDist = dx + dy;
-				best = run.start + i;
-			}
-		}
-	}
-	return best >= 0 ? best : null;
-}
-/** Double-click: the word around `i` (walk to space/empty glyphs both ways). */
-function expandToWord(text, i) {
-	const n = text.glyphs.length;
-	if (i < 0 || i >= n) return [i, i];
-	let from = i;
-	while (from > 0 && !isBoundary(text.glyphs[from - 1].flags)) from--;
-	let to = i;
-	while (to < n - 1 && !isBoundary(text.glyphs[to + 1].flags)) to++;
-	return [from, to];
-}
-/** Triple-click: the full visual line — runs whose vertical extent overlaps the anchor run's. */
-function expandToLine(text, i) {
-	const ri = text.runs.findIndex((r) => i >= r.start && i < r.start + r.count);
-	if (ri < 0) return [i, i];
-	const anchor = text.runs[ri];
-	const top = anchor.rect.y;
-	const bottom = anchor.rect.y + anchor.rect.height;
-	let from = anchor.start;
-	let to = anchor.start + anchor.count - 1;
-	for (let r = ri - 1; r >= 0; r--) {
-		const run = text.runs[r];
-		if (isZero(run.rect)) continue;
-		if (!overlapV(run.rect.y, run.rect.y + run.rect.height, top, bottom)) break;
-		from = run.start;
-	}
-	for (let r = ri + 1; r < text.runs.length; r++) {
-		const run = text.runs[r];
-		if (isZero(run.rect)) continue;
-		if (!overlapV(run.rect.y, run.rect.y + run.rect.height, top, bottom)) break;
-		to = run.start + run.count - 1;
-	}
-	return [from, to];
-}
-const CHAR_DISTANCE_FACTOR = 2.5;
-const FONT_SIZE_RATIO_THRESHOLD = 1.5;
-const VERTICAL_OVERLAP_THRESHOLD = .8;
-const LINE_OVERLAP_THRESHOLD = .5;
-function rectsForRange(text, from, to) {
-	const lo = Math.max(0, Math.min(from, to));
-	const hi = Math.min(text.glyphs.length - 1, Math.max(from, to));
-	const subRuns = [];
-	for (const run of text.runs) {
-		const runEnd = run.start + run.count - 1;
-		if (runEnd < lo || run.start > hi) continue;
-		const s = Math.max(lo, run.start);
-		const e = Math.min(hi, runEnd);
-		let minX = Infinity;
-		let maxX = -Infinity;
-		let minY = Infinity;
-		let maxY = -Infinity;
-		let charCount = 0;
-		let widthSum = 0;
-		let prevRight = -Infinity;
-		const flush = () => {
-			if (minX !== Infinity && charCount > 0) subRuns.push({
-				rect: {
-					x: minX,
-					y: minY,
-					width: maxX - minX,
-					height: maxY - minY
-				},
-				charCount,
-				fontSize: run.fontSize
-			});
-			minX = Infinity;
-			maxX = -Infinity;
-			minY = Infinity;
-			maxY = -Infinity;
-			charCount = 0;
-			widthSum = 0;
-			prevRight = -Infinity;
-		};
-		for (let gi = s; gi <= e; gi++) {
-			const g = text.glyphs[gi];
-			if (isEmpty(g.flags)) continue;
-			const b = g.loose;
-			if (charCount > 0 && prevRight > -Infinity) {
-				const avg = widthSum / charCount;
-				if (avg > 0 && Math.abs(b.x - prevRight) > CHAR_DISTANCE_FACTOR * avg) flush();
-			}
-			minX = Math.min(minX, b.x);
-			maxX = Math.max(maxX, b.x + b.width);
-			minY = Math.min(minY, b.y);
-			maxY = Math.max(maxY, b.y + b.height);
-			charCount++;
-			widthSum += b.width;
-			prevRight = b.x + b.width;
-		}
-		flush();
-	}
-	return mergeAdjacentRects(subRuns);
-}
-function mergeAdjacentRects(runs) {
-	const out = [];
-	let prev = null;
-	let cur = null;
-	for (const run of runs) {
-		if (prev && cur && shouldMerge(prev, run)) cur = boundsOfRects([cur, run.rect]);
-		else {
-			if (cur) out.push(cur);
-			cur = run.rect;
-		}
-		prev = run;
-	}
-	if (cur && cur.width > 0 && cur.height > 0) out.push(cur);
-	return out;
-}
-function shouldMerge(a, b) {
-	if (a.fontSize != null && b.fontSize != null && a.fontSize > 0 && b.fontSize > 0) {
-		if (Math.max(a.fontSize, b.fontSize) / Math.min(a.fontSize, b.fontSize) > FONT_SIZE_RATIO_THRESHOLD) return false;
-	}
-	if (verticalOverlap(a.rect, b.rect) < VERTICAL_OVERLAP_THRESHOLD) return false;
-	const aw = a.rect.width / a.charCount;
-	const bw = b.rect.width / b.charCount;
-	const aL = a.rect.x - aw;
-	const aR = a.rect.x + a.rect.width + aw;
-	const bL = b.rect.x - bw;
-	return aL < b.rect.x + b.rect.width + bw && aR > bL;
-}
-function verticalOverlap(a, b) {
-	if (a.height <= 0 || b.height <= 0) return 0;
-	const u = Math.max(a.y + a.height, b.y + b.height) - Math.min(a.y, b.y);
-	if (u === a.height || u === b.height) return 1;
-	return Math.max(0, Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y)) / u;
+function toContentTextQuad(geom, quad) {
+	const pt = (p) => applyPoint(geom.toContent, p);
+	return {
+		upperStart: pt(quad.p1),
+		upperEnd: pt(quad.p2),
+		lowerStart: pt(quad.p3),
+		lowerEnd: pt(quad.p4)
+	};
 }
-const isZero = (r) => r.width === 0 && r.height === 0;
-function overlapV(top1, bottom1, top2, bottom2) {
-	const u = Math.max(bottom1, bottom2) - Math.min(top1, top2);
-	if (u === 0) return false;
-	return Math.max(0, Math.min(bottom1, bottom2) - Math.max(top1, top2)) / u >= LINE_OVERLAP_THRESHOLD;
+/** A canonical segment in content space (`rect` recomputed from the mapped
+*  quad so the pair can never drift). */
+function toContentSegment(geom, segment) {
+	const quad = toContentTextQuad(geom, segment.quad);
+	return {
+		quad,
+		rect: textQuadBounds(quad),
+		advance: segment.advance
+	};
 }
 //#endregion
 //#region src/capability.ts
-const EMPTY = [];
+const EMPTY_SEGMENTS = [];
 /**
 * The selection capability. The reducer state holds the selection range, the
-* derived content-space rects (per page), and per-page loaded flags; the (large,
-* non-serializable) per-page text geometry is cached HERE in the closure.
+* derived content-space segments (per page), and per-page loaded flags; the
+* (large, non-serializable) per-page canonical layout is cached HERE in the
+* closure. Segmentation itself is the engine-core text layout — selection
+* owns gestures and state, never how glyphs become lines.
 *
-* Selection is cross-page: glyphs are ordered globally by (pageIndex, glyph), so
-* a drag from page 2 into page 4 selects the tail of 2, all of 3, and the head of
-* 4. `recompute` rebuilds the merged line rects for every loaded page in the span
-* and re-runs whenever a mid-span page finishes loading.
+* Selection is cross-page: glyphs are ordered globally by (pageIndex, glyph),
+* so a drag from page 2 into page 4 selects the tail of 2, all of 3, and the
+* head of 4. `recompute` rebuilds the merged line segments for every loaded
+* page in the span and re-runs whenever a mid-span page finishes loading.
 */
 function createSelectionCapability(ctx) {
 	const cache = /* @__PURE__ */ new Map();
@@ -255,6 +85,7 @@ function createSelectionCapability(ctx) {
 	const fireChange = () => changeCbs.forEach((cb) => cb());
 	const pageIndexOf = (pon) => ctx.document()?.pages.findIndex((p) => p.pageObjectNumber === pon) ?? -1;
 	const ponAtIndex = (i) => ctx.document()?.pages[i]?.pageObjectNumber;
+	const glyphAt = (geom, point) => textGlyphAt(geom.layout, contentPointToPdf(geom, point));
 	function orderedEnds(sel) {
 		const ai = pageIndexOf(sel.anchor.pon);
 		const fi = pageIndexOf(sel.focus.pon);
@@ -269,18 +100,32 @@ function createSelectionCapability(ctx) {
 		};
 	}
 	function endpointFor(ptr, which) {
-		const rects = ctx.getState().rects[ptr.pon] ?? EMPTY;
-		if (!rects.length) return null;
+		const segments = ctx.getState().segments[ptr.pon] ?? EMPTY_SEGMENTS;
+		if (!segments.length) return null;
+		const segment = which === "start" ? segments[0] : segments[segments.length - 1];
+		const geom = cache.get(ptr.pon);
+		const cell = geom ? textGlyphQuad(geom.layout, ptr.glyph) : null;
+		if (geom && cell) {
+			const glyphQuad = toContentTextQuad(geom, cell);
+			return {
+				pon: ptr.pon,
+				glyphQuad,
+				advance: segment.advance,
+				rect: textQuadBounds(glyphQuad)
+			};
+		}
 		return {
 			pon: ptr.pon,
-			rect: which === "start" ? rects[0] : rects[rects.length - 1]
+			glyphQuad: segment.quad,
+			advance: segment.advance,
+			rect: segment.rect
 		};
 	}
 	function snapshot() {
-		const { selection, rects } = ctx.getState();
-		const pages = Object.keys(rects).map(Number).filter((pon) => (rects[pon]?.length ?? 0) > 0).map((pon) => ({
+		const { selection, segments } = ctx.getState();
+		const pages = Object.keys(segments).map(Number).filter((pon) => (segments[pon]?.length ?? 0) > 0).map((pon) => ({
 			pon,
-			rects: rects[pon]
+			segments: segments[pon]
 		}));
 		if (!selection) return {
 			pages,
@@ -304,7 +149,7 @@ function createSelectionCapability(ctx) {
 		pending.add(pon);
 		doc.page(pon).geometry.read().then((snapshot) => {
 			pending.delete(pon);
-			cache.set(pon, buildPageText(snapshot, layout.boxes.crop, layout.rotation, layout.userUnit));
+			cache.set(pon, buildSelectionPageGeometry(snapshot, layout.boxes.crop, layout.rotation, layout.userUnit));
 			ctx.dispatch({
 				type: "PAGE_LOADED",
 				pon
@@ -320,30 +165,32 @@ function createSelectionCapability(ctx) {
 		const si = pageIndexOf(start.pon);
 		const ei = pageIndexOf(end.pon);
 		if (si < 0 || ei < 0) return;
-		const rects = {};
+		const segments = {};
 		for (let i = si; i <= ei; i++) {
 			const pon = ponAtIndex(i);
 			if (pon == null) continue;
-			const text = cache.get(pon);
-			if (!text) {
+			const geom = cache.get(pon);
+			if (!geom) {
 				ensurePage(pon);
 				continue;
 			}
-			rects[pon] = rectsForRange(text, i === si ? start.glyph : 0, i === ei ? end.glyph : text.glyphs.length - 1);
+			const from = i === si ? start.glyph : 0;
+			const to = i === ei ? end.glyph : geom.layout.glyphs.length - 1;
+			segments[pon] = textSegmentsForRange(geom.layout, from, to - from + 1).map((s) => toContentSegment(geom, s));
 		}
 		ctx.dispatch({
 			type: "SET",
 			selection: sel,
-			rects
+			segments
 		});
 		fireChange();
 	}
 	function selectSpan(pon, point, expand) {
-		const text = cache.get(pon);
-		if (!text) return;
-		const i = glyphAt(text, point);
+		const geom = cache.get(pon);
+		if (!geom) return;
+		const i = glyphAt(geom, point);
 		if (i == null) return;
-		const [from, to] = expand === "word" ? expandToWord(text, i) : expandToLine(text, i);
+		const [from, to] = expand === "word" ? expandTextRangeToWord(geom.layout, i) : expandTextRangeToLine(geom.layout, i);
 		recompute({
 			anchor: {
 				pon,
@@ -359,13 +206,13 @@ function createSelectionCapability(ctx) {
 		ensurePage,
 		isLoaded: (pon) => !!ctx.getState().loaded[pon],
 		isOverText: (pon, point) => {
-			const text = cache.get(pon);
-			return text ? glyphAt(text, point) != null : false;
+			const geom = cache.get(pon);
+			return geom ? glyphAt(geom, point) != null : false;
 		},
 		beginAt: (pon, point) => {
-			const text = cache.get(pon);
-			if (!text) return false;
-			const i = glyphAt(text, point);
+			const geom = cache.get(pon);
+			if (!geom) return false;
+			const i = glyphAt(geom, point);
 			if (i == null) return false;
 			recompute({
 				anchor: {
@@ -384,12 +231,12 @@ function createSelectionCapability(ctx) {
 		extendTo: (pon, point) => {
 			const cur = ctx.getState().selection;
 			if (!cur) return;
-			const text = cache.get(pon);
-			if (!text) {
+			const geom = cache.get(pon);
+			if (!geom) {
 				ensurePage(pon);
 				return;
 			}
-			const i = glyphAt(text, point);
+			const i = glyphAt(geom, point);
 			if (i == null) return;
 			recompute({
 				anchor: cur.anchor,
@@ -405,11 +252,12 @@ function createSelectionCapability(ctx) {
 			fireChange();
 		},
 		snapshot,
-		rectsForPage: (pon) => ctx.getState().rects[pon] ?? EMPTY,
+		segmentsForPage: (pon) => ctx.getState().segments[pon] ?? EMPTY_SEGMENTS,
+		rectsForPage: (pon) => (ctx.getState().segments[pon] ?? EMPTY_SEGMENTS).map((s) => s.rect),
 		hasSelection: () => ctx.getState().selection != null,
 		selectedPages: () => {
-			const { rects } = ctx.getState();
-			return Object.keys(rects).map(Number).filter((pon) => (rects[pon]?.length ?? 0) > 0);
+			const { segments } = ctx.getState();
+			return Object.keys(segments).map(Number).filter((pon) => (segments[pon]?.length ?? 0) > 0);
 		},
 		onChange: (cb) => {
 			changeCbs.add(cb);
@@ -503,7 +351,7 @@ function createTextSelectHandler(selection, interaction) {
 //#region src/reducer.ts
 const initialSelectionState = {
 	selection: null,
-	rects: {},
+	segments: {},
 	loaded: {},
 	highlightHidden: false
 };
@@ -519,12 +367,12 @@ const selectionReducer = (state, action) => {
 		case "SET": return {
 			...state,
 			selection: action.selection,
-			rects: action.rects
+			segments: action.segments
 		};
-		case "CLEAR": return state.selection === null && Object.keys(state.rects).length === 0 ? state : {
+		case "CLEAR": return state.selection === null && Object.keys(state.segments).length === 0 ? state : {
 			...state,
 			selection: null,
-			rects: {}
+			segments: {}
 		};
 		case "SET_HIGHLIGHT_HIDDEN": return state.highlightHidden === action.hidden ? state : {
 			...state,
@@ -559,6 +407,6 @@ const selectionPlugin = () => definePlugin({
 	}
 });
 //#endregion
-export { SelectionToken, buildPageText, createSelectionCapability, createTextSelectHandler, expandToLine, expandToWord, glyphAt, initialSelectionState, rectsForRange, selectionPlugin, selectionReducer };
+export { SelectionToken, buildSelectionPageGeometry, contentPointToPdf, createSelectionCapability, createTextSelectHandler, initialSelectionState, selectionPlugin, selectionReducer, toContentSegment, toContentTextQuad };
 
 //# sourceMappingURL=index.js.map