@kubb/studio 5.10.2 → 5.10.3

package/dist/index.cjs

@@ -178,7 +178,7 @@ function getElapsedMs(hrStart) {
 }
 //#endregion
 //#region package.json
-var version = "5.10.2";
+var version = "5.10.3";
 //#endregion
 //#region src/resolveConfig.ts
 /**
@@ -1179,33 +1179,154 @@ async function writeConfigEdits({ filePath, edits, extensions }) {
 //#endregion
 //#region src/diff.ts
 const CONTEXT_LINES = 3;
-const DIFF_TIMEOUT_MS = 1e4;
-function diffHunks(before, after) {
-	return new Promise((resolve) => {
-		(0, diff.structuredPatch)("", "", before, after, void 0, void 0, {
+const DIFF_TIMEOUT_MS = 1e3;
+const splitLines = (text) => text === "" ? [] : text.split(/(?<=\n)/);
+function longestIncreasing(values) {
+	const tails = [];
+	const prev = [];
+	for (const [index, value] of values.entries()) {
+		let low = 0;
+		let high = tails.length;
+		while (low < high) {
+			const mid = low + high >> 1;
+			if (values[tails[mid]] < value) low = mid + 1;
+			else high = mid;
+		}
+		prev[index] = low > 0 ? tails[low - 1] : -1;
+		tails[low] = index;
+	}
+	const result = [];
+	for (let index = tails.at(-1) ?? -1; index !== -1; index = prev[index]) result.push(index);
+	return result.reverse();
+}
+function cutPoints(before, after) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const [index, line] of before.entries()) {
+		const count = counts.get(line);
+		if (count) count.before++;
+		else counts.set(line, {
+			before: 1,
+			after: 0,
+			index
+		});
+	}
+	const afterIndex = /* @__PURE__ */ new Map();
+	for (const [index, line] of after.entries()) {
+		const count = counts.get(line);
+		if (!count) continue;
+		count.after++;
+		afterIndex.set(line, index);
+	}
+	const unique = [...counts].filter(([, count]) => count.before === 1 && count.after === 1).map(([line, count]) => [count.index, afterIndex.get(line)]);
+	const anchors = longestIncreasing(unique.map(([, index]) => index)).map((index) => unique[index]);
+	const cuts = [[0, 0]];
+	let run = {
+		before: 0,
+		after: 0,
+		length: 0
+	};
+	const closeRun = () => {
+		if (run.length > 6) cuts.push([run.before + CONTEXT_LINES, run.after + CONTEXT_LINES]);
+	};
+	let i = 0;
+	let j = 0;
+	for (const [anchorBefore, anchorAfter] of anchors) {
+		const unchanged = anchorBefore - i === anchorAfter - j && before.slice(i, anchorBefore).every((line, offset) => line === after[j + offset]);
+		if (unchanged && run.length && run.before + run.length === i) run.length += anchorBefore - i + 1;
+		else {
+			closeRun();
+			run = unchanged ? {
+				before: i,
+				after: j,
+				length: anchorBefore - i + 1
+			} : {
+				before: anchorBefore,
+				after: anchorAfter,
+				length: 1
+			};
+		}
+		i = anchorBefore + 1;
+		j = anchorAfter + 1;
+	}
+	closeRun();
+	cuts.push([before.length, after.length]);
+	return cuts;
+}
+function replaceHunk(before, after) {
+	let start = 0;
+	while (start < before.length && start < after.length && before[start] === after[start]) start++;
+	let end = 0;
+	while (end < before.length - start && end < after.length - start && before[before.length - 1 - end] === after[after.length - 1 - end]) end++;
+	const removed = before.slice(start, before.length - end);
+	const added = after.slice(start, after.length - end);
+	if (!removed.length && !added.length) return [];
+	const lines = (prefix, rows) => rows.flatMap((row) => row.endsWith("\n") ? [`${prefix}${row.slice(0, -1)}`] : [`${prefix}${row}`, "\"]);
+	return [{
+		oldStart: start + 1,
+		oldLines: removed.length,
+		newStart: start + 1,
+		newLines: added.length,
+		lines: [...lines("-", removed), ...lines("+", added)]
+	}];
+}
+function diffHunks(before, after, timeout = DIFF_TIMEOUT_MS) {
+	const beforeLines = splitLines(before);
+	const afterLines = splitLines(after);
+	const cuts = cutPoints(beforeLines, afterLines);
+	const deadline = Date.now() + timeout;
+	const hunks = [];
+	let coarse = false;
+	for (const [index, [beforeStart, afterStart]] of cuts.slice(0, -1).entries()) {
+		const [beforeEnd, afterEnd] = cuts[index + 1];
+		const segmentBefore = beforeLines.slice(beforeStart, beforeEnd);
+		const segmentAfter = afterLines.slice(afterStart, afterEnd);
+		const patch = (0, diff.structuredPatch)("", "", segmentBefore.join(""), segmentAfter.join(""), void 0, void 0, {
 			context: CONTEXT_LINES,
-			timeout: DIFF_TIMEOUT_MS,
-			callback: (patch) => resolve(patch?.hunks)
+			timeout: Math.max(0, deadline - Date.now())
 		});
-	});
+		if (!patch) coarse = true;
+		for (const hunk of patch?.hunks ?? replaceHunk(segmentBefore, segmentAfter)) hunks.push({
+			...hunk,
+			oldStart: hunk.oldStart + beforeStart,
+			newStart: hunk.newStart + afterStart
+		});
+	}
+	const lines = hunks.flatMap((hunk) => hunk.lines);
+	return {
+		hunks,
+		stats: {
+			additions: lines.filter((line) => line[0] === "+").length,
+			deletions: lines.filter((line) => line[0] === "-").length,
+			hunks: hunks.length,
+			lines: lines.length,
+			coarse
+		}
+	};
 }
 function pageHunks({ hunks, cursor, limit }) {
 	const page = [];
-	const end = cursor + limit;
+	let used = 0;
 	let start = 0;
 	for (const [index, hunk] of hunks.entries()) {
-		const next = start + hunk.lines.length;
-		if (next > cursor && start < end) page.push({
+		const offset = Math.max(0, cursor - start);
+		start += hunk.lines.length;
+		const remaining = hunk.lines.length - offset;
+		if (remaining <= 0) continue;
+		if (used > 0 && remaining > limit - used) break;
+		let take = Math.min(remaining, limit - used);
+		if (hunk.lines[offset + take]?.startsWith("\\")) take++;
+		page.push({
 			index,
-			oldStart: hunk.oldStart,
-			newStart: hunk.newStart,
-			lines: hunk.lines.slice(Math.max(0, cursor - start), end - start)
+			...hunk,
+			lines: hunk.lines.slice(offset, offset + take)
 		});
-		start = next;
+		used += take;
+		if (used >= limit) break;
 	}
+	const total = hunks.reduce((sum, hunk) => sum + hunk.lines.length, 0);
 	return {
 		hunks: page,
-		nextCursor: end < start ? end : null
+		nextCursor: cursor + used < total ? cursor + used : null
 	};
 }
 //#endregion
@@ -1441,7 +1562,7 @@ function createGenerationStore({ storage, maxCount, maxMb, ttlMs, now = Date.now
 //#region src/generationEvents.ts
 const MAX_QUEUED_EVENTS = 1024;
 const RESERVED_EVENTS = 64;
-const isDiscardable = (event) => event.type === "kubb:files:processing:update" || event.type === "kubb:info" || event.type === "kubb:success";
+const isDiscardable = (type) => type === "kubb:files:processing:update" || type === "kubb:info" || type === "kubb:success";
 /** Forwards selected Kubb lifecycle events to a native Cap'n Web stream. */
 function createGenerationStream(hooks, jobId) {
 	const unhooks = [];
@@ -1473,7 +1594,7 @@ function createGenerationStream(hooks, jobId) {
 			version: 1,
 			timestamp: Date.now()
 		};
-		if (controller.desiredSize <= RESERVED_EVENTS && isDiscardable(event)) return;
+		if (controller.desiredSize <= RESERVED_EVENTS && isDiscardable(type)) return;
 		if (controller.desiredSize <= 0) {
 			fail(/* @__PURE__ */ new Error(`Generation event stream exceeded ${MAX_QUEUED_EVENTS} queued events`));
 			return;
@@ -1577,7 +1698,10 @@ function createGenerationStream(hooks, jobId) {
 		}]
 	};
 	function forward(type) {
-		on(type, (...args) => emitEvent(type, projections[type](...args)));
+		on(type, (...args) => {
+			emitEvent(type, projections[type](...args));
+			if (!isDiscardable(type)) return new Promise((resolve) => setImmediate(resolve));
+		});
 	}
 	on("kubb:build:start", ({ config }) => {
 		root = config.root;
@@ -2087,7 +2211,14 @@ var Agent = class extends capnweb.RpcTarget {
 		if (beforeContent === void 0) return {
 			hunks: [],
 			nextCursor: null,
-			hasBase: false
+			hasBase: false,
+			stats: {
+				additions: 0,
+				deletions: 0,
+				hunks: 0,
+				lines: 0,
+				coarse: false
+			}
 		};
 		const key = JSON.stringify([
 			jobId,
@@ -2095,25 +2226,21 @@ var Agent = class extends capnweb.RpcTarget {
 			baseSource,
 			path
 		]);
-		let hunks = this.#diffs.get(key);
-		if (!hunks) {
-			hunks = diffHunks(beforeContent, afterContent ?? "");
-			this.#diffs.set(key, hunks);
+		let diff = this.#diffs.get(key);
+		if (!diff) {
+			diff = diffHunks(beforeContent, afterContent ?? "");
+			this.#diffs.set(key, diff);
 			if (this.#diffs.size > 4) this.#diffs.delete(this.#diffs.keys().next().value);
 		}
-		const all = await hunks;
-		if (!all) {
-			this.#diffs.delete(key);
-			return this.#refuse({ message: "The two versions differ too much to diff" });
-		}
 		await this.#logCommand("readDiff", `read the diff of ${path}`);
 		return {
 			...pageHunks({
-				hunks: all,
+				hunks: diff.hunks,
 				cursor,
 				limit
 			}),
-			hasBase: true
+			hasBase: true,
+			stats: diff.stats
 		};
 	}
 };