documents.js 1.60.3 → 1.62.0

package/dist/layout/lattice.cjs

@@ -0,0 +1,139 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/layout/lattice.ts
+function extractLineCandidates(items) {
+	const segments = [];
+	for (const item of items) {
+		if (item.kind === "line") {
+			segments.push({
+				item,
+				x1Pt: item.x1Pt,
+				y1Pt: item.y1Pt,
+				x2Pt: item.x2Pt,
+				y2Pt: item.y2Pt
+			});
+			continue;
+		}
+		if (item.kind === "path" && item.stroke !== void 0 && item.subpaths.length === 1) {
+			const subpath = item.subpaths[0];
+			if (subpath.segments.length === 1 && subpath.segments[0].kind === "line") {
+				const segment = subpath.segments[0];
+				segments.push({
+					item,
+					x1Pt: subpath.startXPt,
+					y1Pt: subpath.startYPt,
+					x2Pt: segment.xPt,
+					y2Pt: segment.yPt
+				});
+			}
+		}
+	}
+	return segments;
+}
+const AXIS_ALIGNMENT_TOLERANCE_PT = .5;
+const MIN_GRIDLINE_LENGTH_PT = 4;
+function classifyAxisLine(seg) {
+	const dx = Math.abs(seg.x2Pt - seg.x1Pt);
+	const dy = Math.abs(seg.y2Pt - seg.y1Pt);
+	if (dy <= AXIS_ALIGNMENT_TOLERANCE_PT && dx >= MIN_GRIDLINE_LENGTH_PT) return {
+		axis: "horizontal",
+		position: (seg.y1Pt + seg.y2Pt) / 2,
+		startPt: Math.min(seg.x1Pt, seg.x2Pt),
+		endPt: Math.max(seg.x1Pt, seg.x2Pt),
+		item: seg.item
+	};
+	if (dx <= AXIS_ALIGNMENT_TOLERANCE_PT && dy >= MIN_GRIDLINE_LENGTH_PT) return {
+		axis: "vertical",
+		position: (seg.x1Pt + seg.x2Pt) / 2,
+		startPt: Math.min(seg.y1Pt, seg.y2Pt),
+		endPt: Math.max(seg.y1Pt, seg.y2Pt),
+		item: seg.item
+	};
+}
+const POSITION_DEDUPE_TOLERANCE_PT = .5;
+function longestContiguousSpan(segments) {
+	const sorted = [...segments].sort((a, b) => a.startPt - b.startPt);
+	let bestStart = sorted[0].startPt;
+	let bestEnd = sorted[0].endPt;
+	let runStart = sorted[0].startPt;
+	let runEnd = sorted[0].endPt;
+	for (const segment of sorted.slice(1)) {
+		if (segment.startPt <= runEnd + POSITION_DEDUPE_TOLERANCE_PT) runEnd = Math.max(runEnd, segment.endPt);
+		else {
+			runStart = segment.startPt;
+			runEnd = segment.endPt;
+		}
+		if (runEnd - runStart > bestEnd - bestStart) {
+			bestStart = runStart;
+			bestEnd = runEnd;
+		}
+	}
+	return {
+		spanPt: bestEnd - bestStart,
+		startPt: bestStart,
+		endPt: bestEnd
+	};
+}
+function dedupeAxisLines(segments, descending) {
+	const sorted = [...segments].sort((a, b) => descending ? b.position - a.position : a.position - b.position);
+	const groups = [];
+	for (const candidate of sorted) {
+		const last = groups[groups.length - 1];
+		if (last !== void 0 && Math.abs(candidate.position - last[0].position) <= POSITION_DEDUPE_TOLERANCE_PT) last.push(candidate);
+		else groups.push([candidate]);
+	}
+	return groups.map((group) => {
+		const { spanPt, startPt, endPt } = longestContiguousSpan(group);
+		return {
+			position: group[0].position,
+			spanPt,
+			startPt,
+			endPt,
+			items: group.map((segment) => segment.item)
+		};
+	});
+}
+const MIN_GRIDLINE_COUNT_PER_AXIS = 3;
+const GRID_SPAN_CONSISTENCY_RATIO = .9;
+function consistentLines(lines) {
+	if (lines.length < MIN_GRIDLINE_COUNT_PER_AXIS) return [];
+	const maxSpanPt = Math.max(...lines.map((l) => l.spanPt));
+	const consistent = lines.filter((l) => l.spanPt >= maxSpanPt * GRID_SPAN_CONSISTENCY_RATIO);
+	return consistent.length >= MIN_GRIDLINE_COUNT_PER_AXIS ? consistent : [];
+}
+function detectGridLattice(items) {
+	const horizontal = [];
+	const vertical = [];
+	for (const seg of extractLineCandidates(items)) {
+		const classified = classifyAxisLine(seg);
+		if (classified === void 0) continue;
+		(classified.axis === "horizontal" ? horizontal : vertical).push(classified);
+	}
+	const rowBoundaries = consistentLines(dedupeAxisLines(horizontal, true));
+	const columnBoundaries = consistentLines(dedupeAxisLines(vertical, false));
+	if (rowBoundaries.length === 0 || columnBoundaries.length === 0) return;
+	const sourceItems = /* @__PURE__ */ new Set();
+	for (const line of [...rowBoundaries, ...columnBoundaries]) for (const item of line.items) sourceItems.add(item);
+	return {
+		rowBoundariesDescPt: rowBoundaries.map((l) => l.position),
+		columnBoundariesAscPt: columnBoundaries.map((l) => l.position),
+		sourceItems
+	};
+}
+const OUTER_EDGE_TOLERANCE_PT = 3;
+function findRowIndex(rowBoundariesDescPt, yPt) {
+	const lastIndex = rowBoundariesDescPt.length - 1;
+	if (yPt > rowBoundariesDescPt[0] + OUTER_EDGE_TOLERANCE_PT || yPt < rowBoundariesDescPt[lastIndex] - OUTER_EDGE_TOLERANCE_PT) return;
+	for (let i = 0; i < lastIndex; i++) if (yPt > rowBoundariesDescPt[i + 1]) return i;
+	return lastIndex - 1;
+}
+function findColumnIndex(columnBoundariesAscPt, xPt) {
+	const lastIndex = columnBoundariesAscPt.length - 1;
+	if (xPt < columnBoundariesAscPt[0] - OUTER_EDGE_TOLERANCE_PT || xPt > columnBoundariesAscPt[lastIndex] + OUTER_EDGE_TOLERANCE_PT) return;
+	for (let j = 0; j < lastIndex; j++) if (xPt < columnBoundariesAscPt[j + 1]) return j;
+	return lastIndex - 1;
+}
+//#endregion
+exports.detectGridLattice = detectGridLattice;
+exports.extractLineCandidates = extractLineCandidates;
+exports.findColumnIndex = findColumnIndex;
+exports.findRowIndex = findRowIndex;

package/dist/layout/lattice.d.cts

@@ -0,0 +1,20 @@
+import { LayoutItem } from "document-schema.js";
+//#region src/layout/lattice.d.ts
+interface LineSegment {
+  readonly item: LayoutItem;
+  readonly x1Pt: number;
+  readonly y1Pt: number;
+  readonly x2Pt: number;
+  readonly y2Pt: number;
+}
+declare function extractLineCandidates(items: readonly LayoutItem[]): LineSegment[];
+interface GridLattice {
+  readonly rowBoundariesDescPt: readonly number[];
+  readonly columnBoundariesAscPt: readonly number[];
+  readonly sourceItems: ReadonlySet<LayoutItem>;
+}
+declare function detectGridLattice(items: readonly LayoutItem[]): GridLattice | undefined;
+declare function findRowIndex(rowBoundariesDescPt: readonly number[], yPt: number): number | undefined;
+declare function findColumnIndex(columnBoundariesAscPt: readonly number[], xPt: number): number | undefined;
+//#endregion
+export { GridLattice, LineSegment, detectGridLattice, extractLineCandidates, findColumnIndex, findRowIndex };

package/dist/layout/lattice.d.ts

@@ -0,0 +1,20 @@
+import { LayoutItem } from "document-schema.js";
+//#region src/layout/lattice.d.ts
+interface LineSegment {
+  readonly item: LayoutItem;
+  readonly x1Pt: number;
+  readonly y1Pt: number;
+  readonly x2Pt: number;
+  readonly y2Pt: number;
+}
+declare function extractLineCandidates(items: readonly LayoutItem[]): LineSegment[];
+interface GridLattice {
+  readonly rowBoundariesDescPt: readonly number[];
+  readonly columnBoundariesAscPt: readonly number[];
+  readonly sourceItems: ReadonlySet<LayoutItem>;
+}
+declare function detectGridLattice(items: readonly LayoutItem[]): GridLattice | undefined;
+declare function findRowIndex(rowBoundariesDescPt: readonly number[], yPt: number): number | undefined;
+declare function findColumnIndex(columnBoundariesAscPt: readonly number[], xPt: number): number | undefined;
+//#endregion
+export { GridLattice, LineSegment, detectGridLattice, extractLineCandidates, findColumnIndex, findRowIndex };

package/dist/layout/lattice.js

@@ -0,0 +1,135 @@
+//#region src/layout/lattice.ts
+function extractLineCandidates(items) {
+	const segments = [];
+	for (const item of items) {
+		if (item.kind === "line") {
+			segments.push({
+				item,
+				x1Pt: item.x1Pt,
+				y1Pt: item.y1Pt,
+				x2Pt: item.x2Pt,
+				y2Pt: item.y2Pt
+			});
+			continue;
+		}
+		if (item.kind === "path" && item.stroke !== void 0 && item.subpaths.length === 1) {
+			const subpath = item.subpaths[0];
+			if (subpath.segments.length === 1 && subpath.segments[0].kind === "line") {
+				const segment = subpath.segments[0];
+				segments.push({
+					item,
+					x1Pt: subpath.startXPt,
+					y1Pt: subpath.startYPt,
+					x2Pt: segment.xPt,
+					y2Pt: segment.yPt
+				});
+			}
+		}
+	}
+	return segments;
+}
+const AXIS_ALIGNMENT_TOLERANCE_PT = .5;
+const MIN_GRIDLINE_LENGTH_PT = 4;
+function classifyAxisLine(seg) {
+	const dx = Math.abs(seg.x2Pt - seg.x1Pt);
+	const dy = Math.abs(seg.y2Pt - seg.y1Pt);
+	if (dy <= AXIS_ALIGNMENT_TOLERANCE_PT && dx >= MIN_GRIDLINE_LENGTH_PT) return {
+		axis: "horizontal",
+		position: (seg.y1Pt + seg.y2Pt) / 2,
+		startPt: Math.min(seg.x1Pt, seg.x2Pt),
+		endPt: Math.max(seg.x1Pt, seg.x2Pt),
+		item: seg.item
+	};
+	if (dx <= AXIS_ALIGNMENT_TOLERANCE_PT && dy >= MIN_GRIDLINE_LENGTH_PT) return {
+		axis: "vertical",
+		position: (seg.x1Pt + seg.x2Pt) / 2,
+		startPt: Math.min(seg.y1Pt, seg.y2Pt),
+		endPt: Math.max(seg.y1Pt, seg.y2Pt),
+		item: seg.item
+	};
+}
+const POSITION_DEDUPE_TOLERANCE_PT = .5;
+function longestContiguousSpan(segments) {
+	const sorted = [...segments].sort((a, b) => a.startPt - b.startPt);
+	let bestStart = sorted[0].startPt;
+	let bestEnd = sorted[0].endPt;
+	let runStart = sorted[0].startPt;
+	let runEnd = sorted[0].endPt;
+	for (const segment of sorted.slice(1)) {
+		if (segment.startPt <= runEnd + POSITION_DEDUPE_TOLERANCE_PT) runEnd = Math.max(runEnd, segment.endPt);
+		else {
+			runStart = segment.startPt;
+			runEnd = segment.endPt;
+		}
+		if (runEnd - runStart > bestEnd - bestStart) {
+			bestStart = runStart;
+			bestEnd = runEnd;
+		}
+	}
+	return {
+		spanPt: bestEnd - bestStart,
+		startPt: bestStart,
+		endPt: bestEnd
+	};
+}
+function dedupeAxisLines(segments, descending) {
+	const sorted = [...segments].sort((a, b) => descending ? b.position - a.position : a.position - b.position);
+	const groups = [];
+	for (const candidate of sorted) {
+		const last = groups[groups.length - 1];
+		if (last !== void 0 && Math.abs(candidate.position - last[0].position) <= POSITION_DEDUPE_TOLERANCE_PT) last.push(candidate);
+		else groups.push([candidate]);
+	}
+	return groups.map((group) => {
+		const { spanPt, startPt, endPt } = longestContiguousSpan(group);
+		return {
+			position: group[0].position,
+			spanPt,
+			startPt,
+			endPt,
+			items: group.map((segment) => segment.item)
+		};
+	});
+}
+const MIN_GRIDLINE_COUNT_PER_AXIS = 3;
+const GRID_SPAN_CONSISTENCY_RATIO = .9;
+function consistentLines(lines) {
+	if (lines.length < MIN_GRIDLINE_COUNT_PER_AXIS) return [];
+	const maxSpanPt = Math.max(...lines.map((l) => l.spanPt));
+	const consistent = lines.filter((l) => l.spanPt >= maxSpanPt * GRID_SPAN_CONSISTENCY_RATIO);
+	return consistent.length >= MIN_GRIDLINE_COUNT_PER_AXIS ? consistent : [];
+}
+function detectGridLattice(items) {
+	const horizontal = [];
+	const vertical = [];
+	for (const seg of extractLineCandidates(items)) {
+		const classified = classifyAxisLine(seg);
+		if (classified === void 0) continue;
+		(classified.axis === "horizontal" ? horizontal : vertical).push(classified);
+	}
+	const rowBoundaries = consistentLines(dedupeAxisLines(horizontal, true));
+	const columnBoundaries = consistentLines(dedupeAxisLines(vertical, false));
+	if (rowBoundaries.length === 0 || columnBoundaries.length === 0) return;
+	const sourceItems = /* @__PURE__ */ new Set();
+	for (const line of [...rowBoundaries, ...columnBoundaries]) for (const item of line.items) sourceItems.add(item);
+	return {
+		rowBoundariesDescPt: rowBoundaries.map((l) => l.position),
+		columnBoundariesAscPt: columnBoundaries.map((l) => l.position),
+		sourceItems
+	};
+}
+const OUTER_EDGE_TOLERANCE_PT = 3;
+function findRowIndex(rowBoundariesDescPt, yPt) {
+	const lastIndex = rowBoundariesDescPt.length - 1;
+	if (yPt > rowBoundariesDescPt[0] + OUTER_EDGE_TOLERANCE_PT || yPt < rowBoundariesDescPt[lastIndex] - OUTER_EDGE_TOLERANCE_PT) return;
+	for (let i = 0; i < lastIndex; i++) if (yPt > rowBoundariesDescPt[i + 1]) return i;
+	return lastIndex - 1;
+}
+function findColumnIndex(columnBoundariesAscPt, xPt) {
+	const lastIndex = columnBoundariesAscPt.length - 1;
+	if (xPt < columnBoundariesAscPt[0] - OUTER_EDGE_TOLERANCE_PT || xPt > columnBoundariesAscPt[lastIndex] + OUTER_EDGE_TOLERANCE_PT) return;
+	for (let j = 0; j < lastIndex; j++) if (xPt < columnBoundariesAscPt[j + 1]) return j;
+	return lastIndex - 1;
+}
+//#endregion
+export { detectGridLattice, extractLineCandidates, findColumnIndex, findRowIndex };