@dev.fast/whiteboard 0.3.4 → 0.3.5-preview.20261020.130

package/dist/{headless-host-CVBOQyRS.js → headless-host-cYdlRYPB.js}

@@ -1,2 +1,2 @@
-import { i as withHeadlessServerLock, n as runHeadlessServer, r as takeOverServerHome, t as HeadlessServerBusyError } from "./headless-host-Cog6SpS9.js";
+import { i as withHeadlessServerLock, n as runHeadlessServer, r as takeOverServerHome, t as HeadlessServerBusyError } from "./headless-host-C7xYMe74.js";
 export { HeadlessServerBusyError, runHeadlessServer, takeOverServerHome, withHeadlessServerLock };

package/dist/lens-selection-CAtsGaym.js

@@ -0,0 +1,214 @@
+import "./src-CyYCvVHx.js";
+import { z } from "zod";
+//#region src/viewed-coverage.ts
+const coverageSchema = z.object({
+	base: z.array(z.tuple([z.number().int().nonnegative(), z.number().int().nonnegative()])),
+	head: z.array(z.tuple([z.number().int().nonnegative(), z.number().int().nonnegative()]))
+});
+const emptyCoverage = () => ({
+	base: [],
+	head: []
+});
+function unionIntervals(ranges) {
+	const result = [];
+	for (const [start, end] of [...ranges].sort((a, b) => a[0] - b[0])) {
+		if (end <= start) continue;
+		const last = result.at(-1);
+		if (last && start <= last[1]) last[1] = Math.max(last[1], end);
+		else result.push([start, end]);
+	}
+	return result;
+}
+function intersectIntervals(left, right) {
+	const result = [];
+	const a = unionIntervals(left), b = unionIntervals(right);
+	let i = 0, j = 0;
+	while (i < a.length && j < b.length) {
+		const start = Math.max(a[i][0], b[j][0]), end = Math.min(a[i][1], b[j][1]);
+		if (start < end) result.push([start, end]);
+		if (a[i][1] < b[j][1]) i++;
+		else j++;
+	}
+	return result;
+}
+function subtractIntervals(left, right) {
+	const result = [];
+	const removed = unionIntervals(right);
+	for (const [start, end] of unionIntervals(left)) {
+		let cursor = start;
+		for (const [from, to] of removed) {
+			if (to <= cursor) continue;
+			if (from >= end) break;
+			if (from > cursor) result.push([cursor, from]);
+			cursor = Math.min(end, Math.max(cursor, to));
+		}
+		if (cursor < end) result.push([cursor, end]);
+	}
+	return result;
+}
+function updateCoverage(current, scope, viewed) {
+	const apply = (side) => viewed ? unionIntervals([...current[side], ...scope[side]]) : subtractIntervals(current[side], scope[side]);
+	return {
+		base: apply("base"),
+		head: apply("head")
+	};
+}
+function scopedCoverage(file, sources) {
+	if (!sources) return file.changed;
+	const side = (side) => intersectIntervals(file.changed[side], sources.flatMap((source) => source.side === side && source.file === (side === "base" ? file.previousPath ?? file.path : file.path) ? [[source.fromLine - 1, source.toLine]] : []));
+	return {
+		base: side("base"),
+		head: side("head")
+	};
+}
+function coverageSources(file, coverage = file.viewed) {
+	return ["base", "head"].flatMap((side) => coverage[side].map(([start, end]) => ({
+		side,
+		file: side === "base" ? file.previousPath ?? file.path : file.path,
+		fromLine: start + 1,
+		toLine: end
+	})));
+}
+//#endregion
+//#region src/lens-selection.ts
+const ANCHOR_FORMS = "\"head/path#L10-L24\" or \"base/path#L7\" (one side, lines 10–24 or line 7); across sides, GitHub diff style \"diff/path#L84-R90\" (L = base line, R = head line)";
+const sameSideAnchor = /^(head|base)\/(.+)#L(\d+)(?:-L(\d+))?$/;
+const crossSideAnchor = /^diff\/(.+)#([LR])(\d+)-([LR])(\d+)$/;
+const commitLinkAnchor = /^([0-9a-f]{7,40})\/(.+#L\d+(?:-L\d+)?)$/i;
+/** A source link's commit form, "<sha>/path#L10-L24" (without its
+* `whiteboard:source/` prefix): lines of that commit of the board's own
+* repository, read as their head side. Undefined for any other form. */
+function commitLinkTarget(target) {
+	const match = commitLinkAnchor.exec(target);
+	return match ? {
+		commit: match[1].toLowerCase(),
+		anchor: `head/${match[2]}`
+	} : void 0;
+}
+/** An anchor's selection, as markdown source links write it too (without
+* their `whiteboard:source/` prefix). Undefined when it isn't one. */
+function parseAnchor(text) {
+	const same = sameSideAnchor.exec(text);
+	if (same) {
+		const side = same[1] === "base" ? "base" : "head";
+		return {
+			file: same[2],
+			start: {
+				side,
+				line: Number(same[3])
+			},
+			end: {
+				side,
+				line: Number(same[4] ?? same[3])
+			}
+		};
+	}
+	const cross = crossSideAnchor.exec(text);
+	if (!cross || cross[2] === cross[4]) return void 0;
+	const side = (letter) => letter === "L" ? "base" : "head";
+	return {
+		file: cross[1],
+		start: {
+			side: side(cross[2]),
+			line: Number(cross[3])
+		},
+		end: {
+			side: side(cross[4]),
+			line: Number(cross[5])
+		}
+	};
+}
+/** Why a parsed selection can't be quoted, or undefined when it can. */
+function selectionProblem(selection) {
+	if (selection.start.line < 1 || selection.end.line < 1) return "Source lines count from 1.";
+	if (selection.start.side === selection.end.side && selection.start.line > selection.end.line) return "Source range ends before it starts.";
+	if (selection.pins && selection.pins.base === void 0 && (selection.start.side === "base" || selection.end.side === "base")) return "A base-side anchor needs base pins.";
+}
+const anchorSchema = z.string({ error: `Expected a source anchor: ${ANCHOR_FORMS}.` }).superRefine((text, context) => {
+	const selection = parseAnchor(text);
+	const problem = selection ? selectionProblem(selection) : `Use ${ANCHOR_FORMS} for a source anchor.`;
+	if (problem) context.addIssue({
+		code: "custom",
+		message: problem
+	});
+}).describe("head/path#L10-L24, base/path#L7, or diff/path#L84-R90");
+/** A stored anchor's selection, read at the pins of whatever holds it. */
+function anchorSelection(anchor, pins) {
+	const selection = parseAnchor(anchor);
+	if (!selection) throw new Error(`Not a source anchor: ${anchor}`);
+	return pins ? {
+		...selection,
+		pins
+	} : selection;
+}
+/** The anchor that writes a selection; its pins belong to its holder. */
+function formatAnchor(selection) {
+	const { file, start, end } = selection;
+	if (start.side === end.side) return start.line === end.line ? `${start.side}/${file}#L${start.line}` : `${start.side}/${file}#L${start.line}-L${end.line}`;
+	const letter = (side) => side === "base" ? "L" : "R";
+	return `diff/${file}#${letter(start.side)}${start.line}-${letter(end.side)}${end.line}`;
+}
+/** Pins-less selections keep the key they always had. */
+function selectionKey(source) {
+	return JSON.stringify([
+		source.file,
+		source.start.side,
+		source.start.line,
+		source.end.side,
+		source.end.line,
+		...source.pins ? [sourcePinsKey(source.pins)] : []
+	]);
+}
+function sourcePinsKey(pins) {
+	return `${pins.repositoryId}:${pins.base ?? ""}:${pins.head}`;
+}
+/** The comparison a source's pins name: head alone means head against
+* itself. Reference coverage is grouped under this key on both sides. */
+function comparisonKey(pins) {
+	return `${pins.repositoryId}:${pins.base ?? pins.head}:${pins.head}`;
+}
+/** Navigation/quote anchors only; never use these as lens coverage. */
+function sourceAnchors(source) {
+	return ["head", "base"].flatMap((side) => {
+		const lines = [source.start, source.end].flatMap((endpoint) => endpoint.side === side ? [endpoint.line] : []);
+		if (!lines.length) return [];
+		const anchor = {
+			file: source.file,
+			side,
+			fromLine: Math.min(...lines),
+			toLine: Math.max(...lines)
+		};
+		if (source.pins) anchor.pins = source.pins;
+		return [anchor];
+	});
+}
+/** Why a selection cannot be resolved at its pins, as telemetry reports it. */
+const SELECTION_UNAVAILABLE_REASONS = [
+	"missing_file",
+	"no_alignment",
+	"outside_lines",
+	"other"
+];
+var SelectionUnavailableError = class extends Error {
+	reason;
+	constructor(reason, message) {
+		super(message);
+		this.reason = reason;
+	}
+};
+/** Resolve once against the renderer's rows. No matching or context expansion. */
+function resolveDiffSelection(source, rows, file) {
+	const locate = (endpoint) => rows.findIndex((row) => row[endpoint.side === "base" ? 0 : 1] === endpoint.line - 1);
+	const start = locate(source.start);
+	const end = locate(source.end);
+	if (start < 0 || end < start) throw new SelectionUnavailableError("outside_lines", "Lens endpoints do not identify an ordered interval in this diff.");
+	const selected = rows.slice(start, end + 1);
+	return ["base", "head"].flatMap((side, index) => unionIntervals(selected.flatMap((row) => row[index] === null ? [] : [[row[index], row[index] + 1]])).map(([from, to]) => ({
+		file: side === "base" ? file.previousPath ?? file.path : file.path,
+		side,
+		fromLine: from + 1,
+		toLine: to
+	})));
+}
+//#endregion
+export { scopedCoverage as _, commitLinkTarget as a, updateCoverage as b, parseAnchor as c, selectionProblem as d, sourceAnchors as f, intersectIntervals as g, emptyCoverage as h, anchorSelection as i, resolveDiffSelection as l, coverageSources as m, SelectionUnavailableError as n, comparisonKey as o, coverageSchema as p, anchorSchema as r, formatAnchor as s, SELECTION_UNAVAILABLE_REASONS as t, selectionKey as u, subtractIntervals as v, unionIntervals as y };