@pierre/diffs 1.2.0-beta.6 → 1.2.1

package/dist/worker/WorkerPoolManager.js

@@ -4,11 +4,13 @@ import { attachResolvedThemes } from "../highlighter/themes/attachResolvedThemes
 import { getSharedHighlighter } from "../highlighter/shared_highlighter.js";
 import { getThemes } from "../utils/getThemes.js";
 import { hasResolvedThemes } from "../highlighter/themes/hasResolvedThemes.js";
+import { areFileRenderOptionsEqual } from "../utils/areFileRenderOptionsEqual.js";
+import { areFilesEqual } from "../utils/areFilesEqual.js";
 import { getCustomExtensionsMap, getCustomExtensionsVersion, getFiletypeFromFileName } from "../utils/getFiletypeFromFileName.js";
 import { isFilePlainText } from "../utils/isFilePlainText.js";
 import { renderFileWithHighlighter } from "../utils/renderFileWithHighlighter.js";
-import { areFilesEqual } from "../utils/areFilesEqual.js";
 import { areDiffRenderOptionsEqual } from "../utils/areDiffRenderOptionsEqual.js";
+import { areDiffTargetsEqual } from "../utils/areDiffTargetsEqual.js";
 import { isDiffPlainText } from "../utils/isDiffPlainText.js";
 import { renderDiffWithHighlighter } from "../utils/renderDiffWithHighlighter.js";
 import { getResolvedLanguages } from "../highlighter/languages/getResolvedLanguages.js";
@@ -29,14 +31,17 @@ var WorkerPoolManager = class {
 	highlighter;
 	preferredHighlighter;
 	renderOptions;
+	renderOptionsVersion = 0;
 	initialized = false;
 	workers = [];
-	taskQueue = /* @__PURE__ */ new Map();
-	pendingTasks = /* @__PURE__ */ new Map();
+	queuedTasks = [];
+	queuedTaskByInstance = /* @__PURE__ */ new Map();
+	taskByHighlightKey = /* @__PURE__ */ new Map();
+	activeTaskById = /* @__PURE__ */ new Map();
+	activeRequestByInstance = /* @__PURE__ */ new Map();
 	nextRequestId = 0;
 	themeSubscribers = /* @__PURE__ */ new Set();
 	workersFailed = false;
-	instanceRequestMap = /* @__PURE__ */ new Map();
 	statSubscribers = /* @__PURE__ */ new Set();
 	fileCache;
 	diffCache;
@@ -117,6 +122,7 @@ var WorkerPoolManager = class {
 			}
 			if (!this.isCurrentLifecycle(lifecycleGeneration)) return;
 			this.renderOptions = newRenderOptions;
+			this.renderOptionsVersion++;
 			this.diffCache.clear();
 			this.fileCache.clear();
 			for (const instance of this.themeSubscribers) instance.rerender();
@@ -160,7 +166,7 @@ var WorkerPoolManager = class {
 					reject,
 					requestStart: Date.now()
 				};
-				this.pendingTasks.set(id, task);
+				this.activeTaskById.set(id, task);
 				managedWorker.worker.postMessage(task.request);
 			}));
 		}
@@ -197,13 +203,17 @@ var WorkerPoolManager = class {
 		const stats = this.getStats();
 		for (const callback of this.statSubscribers) callback(stats);
 	};
-	cleanUpPendingTasks(instance) {
-		this.taskQueue.delete(instance);
-		const requestId = this.instanceRequestMap.get(instance);
+	cleanUpTasks(instance) {
+		this.detachInstanceFromQueuedTasks(instance);
+		const requestId = this.activeRequestByInstance.get(instance);
 		if (requestId != null) {
-			this.pendingTasks.delete(requestId);
-			this.instanceRequestMap.delete(instance);
+			const task = this.activeTaskById.get(requestId);
+			if (isRenderTask(task)) {
+				this.detachInstanceFromRenderTask(task, instance);
+				if (!task.primeCache && task.instances.size === 0) this.removeActiveTask(task);
+			} else this.activeTaskById.delete(requestId);
 		}
+		this.activeRequestByInstance.delete(instance);
 		this.queueBroadcastStateChanges();
 	}
 	isInitialized() {
@@ -305,7 +315,7 @@ var WorkerPoolManager = class {
 					reject,
 					requestStart: Date.now()
 				};
-				this.pendingTasks.set(id, task);
+				this.activeTaskById.set(id, task);
 				this.executeTask(managedWorker, task);
 			}));
 		}
@@ -313,25 +323,45 @@ var WorkerPoolManager = class {
 	}
 	drainQueue = () => {
 		this._queuedDrain = void 0;
-		if (this.initialized !== true || this.taskQueue.size === 0) return;
-		for (const [instance, task] of this.taskQueue) {
-			if (this.instanceRequestMap.has(instance)) continue;
+		if (this.initialized !== true || this.queuedTasks.length === 0) return;
+		for (let i = 0; i < this.queuedTasks.length;) {
+			const task = this.queuedTasks[i];
+			if (this.hasActiveRequest(task)) {
+				i++;
+				continue;
+			}
 			const langs = getLangsFromTask(task);
 			const availableWorker = this.getAvailableWorker(langs);
 			if (availableWorker == null) break;
+			this.queuedTasks.splice(i, 1);
 			this.assignWorkerToTask(task, availableWorker);
 			this.resolveLanguagesAndExecuteTask(availableWorker, task, langs);
 		}
 		this.queueBroadcastStateChanges();
 	};
 	highlightFileAST(instance, file) {
-		if (isFilePlainText(file)) return;
-		for (const tasks of [this.taskQueue, this.pendingTasks.values()]) for (const task of tasks) if ("instance" in task && task.instance === instance && task.request.type === "file" && areFilesEqual(file, task.request.file)) return;
-		this.submitTask(instance, {
+		const cachedResult = this.getFileResultCache(file);
+		if (isFilePlainText(file) || cachedResult != null && areFileRenderOptionsEqual(cachedResult.options, this.getFileRenderOptions())) return;
+		if (!this.hasMatchingFileInstanceTask(instance, file)) this.submitTask(instance, {
 			type: "file",
 			file
 		});
 	}
+	primeFileHighlightCache(file) {
+		if (file.cacheKey == null) {
+			console.warn(`WorkerPoolManager.primeFileHighlightCache: priming highlight cache requires file.cacheKey; skipping "${file.name}".`);
+			return;
+		}
+		const cachedResult = this.getFileResultCache(file);
+		const highlightKey = this.getFileHighlightKey(file);
+		if (highlightKey == null || isFilePlainText(file) || cachedResult != null && areFileRenderOptionsEqual(cachedResult.options, this.getFileRenderOptions())) return;
+		const existingTask = this.getTaskByHighlightKey(highlightKey);
+		if (existingTask != null) existingTask.primeCache = true;
+		else this.submitCacheTask({
+			type: "file",
+			file
+		}, highlightKey);
+	}
 	getPlainFileAST(file, startingLine, totalLines, lines) {
 		if (this.highlighter == null) {
 			this.queueInitialization();
@@ -345,13 +375,28 @@ var WorkerPoolManager = class {
 		});
 	}
 	highlightDiffAST(instance, diff) {
-		if (isDiffPlainText(diff)) return;
-		for (const tasks of [this.taskQueue, this.pendingTasks.values()]) for (const task of tasks) if ("instance" in task && task.instance === instance && task.request.type === "diff" && task.request.diff === diff) return;
-		this.submitTask(instance, {
+		const cachedResult = this.getDiffResultCache(diff);
+		if (isDiffPlainText(diff) || cachedResult != null && areDiffRenderOptionsEqual(cachedResult.options, this.getDiffRenderOptions())) return;
+		if (!this.hasMatchingDiffInstanceTask(instance, diff)) this.submitTask(instance, {
 			type: "diff",
 			diff
 		});
 	}
+	primeDiffHighlightCache(diff) {
+		if (diff.cacheKey == null) {
+			console.warn(`WorkerPoolManager.primeDiffHighlightCache: priming highlight cache requires diff.cacheKey; skipping "${diff.prevName ?? diff.name}" -> "${diff.name}".`);
+			return;
+		}
+		const cachedResult = this.getDiffResultCache(diff);
+		const highlightKey = this.getDiffHighlightKey(diff);
+		if (highlightKey == null || isDiffPlainText(diff) || cachedResult != null && areDiffRenderOptionsEqual(cachedResult.options, this.getDiffRenderOptions())) return;
+		const existingTask = this.getTaskByHighlightKey(highlightKey);
+		if (existingTask != null) existingTask.primeCache = true;
+		else this.submitCacheTask({
+			type: "diff",
+			diff
+		}, highlightKey);
+	}
 	getPlainDiffAST(diff, startingLine, totalLines, expandedHunks, collapsedContextThreshold) {
 		return this.highlighter != null ? renderDiffWithHighlighter(diff, this.highlighter, this.renderOptions, {
 			forcePlainText: true,
@@ -363,13 +408,15 @@ var WorkerPoolManager = class {
 	}
 	terminate() {
 		this.lifecycleGeneration++;
-		this.cancelPendingAsyncWorkerTasks();
+		this.cancelActiveWorkerTasks();
 		this.terminateWorkers();
 		this.fileCache.clear();
 		this.diffCache.clear();
-		this.instanceRequestMap.clear();
-		this.taskQueue.clear();
-		this.pendingTasks.clear();
+		this.activeRequestByInstance.clear();
+		this.queuedTasks.length = 0;
+		this.queuedTaskByInstance.clear();
+		this.taskByHighlightKey.clear();
+		this.activeTaskById.clear();
 		this.highlighter = void 0;
 		this.initialized = false;
 		this.workersFailed = false;
@@ -383,9 +430,9 @@ var WorkerPoolManager = class {
 			console.error(error);
 		});
 	}
-	cancelPendingAsyncWorkerTasks() {
+	cancelActiveWorkerTasks() {
 		const error = new WorkerPoolTerminatedError();
-		for (const task of this.pendingTasks.values()) if ("reject" in task) task.reject(error);
+		for (const task of this.activeTaskById.values()) if ("reject" in task) task.reject(error);
 	}
 	terminateWorkers() {
 		for (const managedWorker of this.workers) managedWorker.worker.terminate();
@@ -401,14 +448,57 @@ var WorkerPoolManager = class {
 			totalWorkers: this.workers.length,
 			workersFailed: this.workersFailed,
 			busyWorkers: this.workers.filter((w) => w.request_id != null).length,
-			queuedTasks: this.taskQueue.size,
-			pendingTasks: this.pendingTasks.size,
+			queuedTasks: this.queuedTasks.length,
+			activeTasks: this.activeTaskById.size,
 			themeSubscribers: this.themeSubscribers.size,
 			fileCacheSize: this.fileCache.size,
 			diffCacheSize: this.diffCache.size
 		};
 	}
 	submitTask(instance, request) {
+		if (this.initialized === false) this.queueInitialization();
+		const highlightKey = this.getHighlightKeyForRequest(request);
+		const existingTask = highlightKey != null ? this.getTaskByHighlightKey(highlightKey) : void 0;
+		if (existingTask != null) {
+			this.detachInstanceFromQueuedTasks(instance, existingTask);
+			this.addInstanceToTask(existingTask, instance);
+			this.queueBroadcastStateChanges();
+			return;
+		}
+		this.detachInstanceFromQueuedTasks(instance);
+		const id = this.generateRequestId();
+		const requestStart = Date.now();
+		const task = (() => {
+			switch (request.type) {
+				case "file": return {
+					type: "file",
+					id,
+					request: {
+						...request,
+						id
+					},
+					instances: new Set([instance]),
+					primeCache: false,
+					highlightKey,
+					requestStart
+				};
+				case "diff": return {
+					type: "diff",
+					id,
+					request: {
+						...request,
+						id
+					},
+					instances: new Set([instance]),
+					primeCache: false,
+					highlightKey,
+					requestStart
+				};
+			}
+		})();
+		this.enqueueRenderTask(task, instance);
+	}
+	submitCacheTask(request, highlightKey) {
 		if (this.initialized === false) this.queueInitialization();
 		const id = this.generateRequestId();
 		const requestStart = Date.now();
@@ -421,7 +511,9 @@ var WorkerPoolManager = class {
 						...request,
 						id
 					},
-					instance,
+					instances: /* @__PURE__ */ new Set(),
+					primeCache: true,
+					highlightKey,
 					requestStart
 				};
 				case "diff": return {
@@ -431,12 +523,19 @@ var WorkerPoolManager = class {
 						...request,
 						id
 					},
-					instance,
+					instances: /* @__PURE__ */ new Set(),
+					primeCache: true,
+					highlightKey,
 					requestStart
 				};
 			}
 		})();
-		this.taskQueue.set(instance, task);
+		this.enqueueRenderTask(task);
+	}
+	enqueueRenderTask(task, instance) {
+		this.queuedTasks.push(task);
+		if (instance != null) this.queuedTaskByInstance.set(instance, task);
+		if (task.highlightKey != null) this.taskByHighlightKey.set(task.highlightKey, task);
 		this.queueDrain();
 	}
 	async resolveLanguagesAndExecuteTask(availableWorker, task, langs) {
@@ -444,57 +543,65 @@ var WorkerPoolManager = class {
 			const workerMissingLangs = langs.filter((lang) => !availableWorker.langs.has(lang));
 			if (workerMissingLangs.length > 0) if (hasResolvedLanguages(workerMissingLangs)) task.request.resolvedLanguages = getResolvedLanguages(workerMissingLangs);
 			else task.request.resolvedLanguages = await resolveLanguages(workerMissingLangs);
+			if (!this.activeTaskById.has(task.id)) {
+				if (availableWorker.request_id === task.id) {
+					this.cleanWorkerAndTask(availableWorker, task);
+					this.queueBroadcastStateChanges();
+					if (this.queuedTasks.length > 0) this.queueDrain();
+				}
+				return;
+			}
 			this.executeTask(availableWorker, task);
 		} catch {
 			this.cleanWorkerAndTask(availableWorker, task);
+			this.queueBroadcastStateChanges();
+			if (this.queuedTasks.length > 0) this.queueDrain();
 		}
 	}
 	handleWorkerMessage(managedWorker, response) {
-		const task = this.pendingTasks.get(response.id);
+		const task = this.activeTaskById.get(response.id);
 		try {
 			if (task == null) throw IGNORE_RESPONSE;
 			else if (response.type === "error") {
 				const error = new Error(response.error);
 				if (response.stack) error.stack = response.stack;
 				if ("reject" in task) task.reject(error);
-				else task.instance.onHighlightError(error);
+				else if (isRenderTask(task)) this.notifyHighlightError(task, error);
+				else throw new Error("handleWorkerMessage: unknown task type");
 				throw error;
-			} else {
-				if ("instance" in task && this.instanceRequestMap.get(task.instance) !== response.id) throw IGNORE_RESPONSE;
-				switch (response.requestType) {
-					case "initialize":
-						if (task.type !== "initialize") throw new Error("handleWorkerMessage: task/response dont match");
-						this.syncCustomExtensionVersion(managedWorker, task.request);
-						task.resolve();
-						break;
-					case "set-render-options":
-						if (task.type !== "set-render-options") throw new Error("handleWorkerMessage: task/response dont match");
-						task.resolve();
-						break;
-					case "file": {
-						if (task.type !== "file") throw new Error("handleWorkerMessage: task/response dont match");
-						const { result, options } = response;
-						const { instance, request } = task;
-						this.syncCustomExtensionVersion(managedWorker, request);
-						if (request.file.cacheKey != null) this.fileCache.set(request.file.cacheKey, {
-							result,
-							options
-						});
-						instance.onHighlightSuccess(request.file, result, options);
-						break;
-					}
-					case "diff": {
-						if (task.type !== "diff") throw new Error("handleWorkerMessage: task/response dont match");
-						const { result, options } = response;
-						const { instance, request } = task;
-						this.syncCustomExtensionVersion(managedWorker, request);
-						if (request.diff.cacheKey != null) this.diffCache.set(request.diff.cacheKey, {
-							result,
-							options
-						});
-						instance.onHighlightSuccess(request.diff, result, options);
-						break;
-					}
+			} else switch (response.requestType) {
+				case "initialize":
+					if (task.type !== "initialize") throw new Error("handleWorkerMessage: task/response dont match");
+					this.syncCustomExtensionVersion(managedWorker, task.request);
+					task.resolve();
+					break;
+				case "set-render-options":
+					if (task.type !== "set-render-options") throw new Error("handleWorkerMessage: task/response dont match");
+					task.resolve();
+					break;
+				case "file": {
+					if (task.type !== "file") throw new Error("handleWorkerMessage: task/response dont match");
+					const { result, options } = response;
+					const { request } = task;
+					this.syncCustomExtensionVersion(managedWorker, request);
+					if (request.file.cacheKey != null) this.fileCache.set(request.file.cacheKey, {
+						result,
+						options
+					});
+					this.notifyFileInstances(task, result, options);
+					break;
+				}
+				case "diff": {
+					if (task.type !== "diff") throw new Error("handleWorkerMessage: task/response dont match");
+					const { result, options } = response;
+					const { request } = task;
+					this.syncCustomExtensionVersion(managedWorker, request);
+					if (request.diff.cacheKey != null) this.diffCache.set(request.diff.cacheKey, {
+						result,
+						options
+					});
+					this.notifyDiffInstances(task, result, options);
+					break;
 				}
 			}
 		} catch (error) {
@@ -502,7 +609,7 @@ var WorkerPoolManager = class {
 		}
 		this.cleanWorkerAndTask(managedWorker, task);
 		this.queueBroadcastStateChanges();
-		if (this.taskQueue.size > 0) this.queueDrain();
+		if (this.queuedTasks.length > 0) this.queueDrain();
 	}
 	_queuedDrain;
 	queueDrain() {
@@ -512,30 +619,34 @@ var WorkerPoolManager = class {
 	}
 	assignWorkerToTask(task, managedWorker) {
 		managedWorker.request_id = task.id;
-		if ("instance" in task) {
-			this.taskQueue.delete(task.instance);
-			this.instanceRequestMap.set(task.instance, task.id);
+		if (isRenderTask(task)) {
+			this.clearQueuedInstanceRequests(task);
+			this.trackInstanceRequests(task);
 		}
-		this.pendingTasks.set(task.id, task);
+		this.activeTaskById.set(task.id, task);
 	}
 	cleanWorkerAndTask(managedWorker, task) {
 		managedWorker.request_id = void 0;
 		if (task != null) {
-			if ("instance" in task) this.instanceRequestMap.delete(task.instance);
-			this.pendingTasks.delete(task.id);
+			if (isRenderTask(task)) {
+				this.clearInstanceRequests(task);
+				this.clearHighlightKey(task);
+			}
+			this.activeTaskById.delete(task.id);
 		}
 	}
 	executeTask(managedWorker, task) {
 		if (shouldSyncCustomExtensions(task.request)) this.maybeAttachCustomExtensions(managedWorker, task.request);
-		this.assignWorkerToTask(task, managedWorker);
+		if (!this.activeTaskById.has(task.id)) this.assignWorkerToTask(task, managedWorker);
 		for (const lang of getLangsFromTask(task)) managedWorker.langs.add(lang);
 		try {
 			managedWorker.worker.postMessage(task.request);
 		} catch (error) {
-			this.cleanWorkerAndTask(managedWorker, task);
 			console.error("Failed to post message to worker:", error);
-			if ("instance" in task) task.instance.onHighlightError(error);
+			if (isRenderTask(task)) this.notifyHighlightError(task, error);
 			else if ("reject" in task) task.reject(error);
+			this.cleanWorkerAndTask(managedWorker, task);
+			if (this.queuedTasks.length > 0) this.queueDrain();
 		}
 		this.queueBroadcastStateChanges();
 	}
@@ -565,6 +676,88 @@ var WorkerPoolManager = class {
 		}
 		return worker;
 	}
+	getFileHighlightKey(file) {
+		if (file.cacheKey == null) return;
+		return `file:${file.cacheKey}:${this.renderOptionsVersion}`;
+	}
+	getDiffHighlightKey(diff) {
+		if (diff.cacheKey == null) return;
+		return `diff:${diff.cacheKey}:${this.renderOptionsVersion}`;
+	}
+	getHighlightKeyForRequest(request) {
+		switch (request.type) {
+			case "file": return this.getFileHighlightKey(request.file);
+			case "diff": return this.getDiffHighlightKey(request.diff);
+		}
+	}
+	hasActiveRequest(task) {
+		for (const instance of getInstances(task)) if (this.activeRequestByInstance.has(instance)) return true;
+		return false;
+	}
+	addInstanceToTask(task, instance) {
+		if (task.type === "file") task.instances.add(instance);
+		else task.instances.add(instance);
+		if (this.activeTaskById.has(task.id)) this.activeRequestByInstance.set(instance, task.id);
+		else this.queuedTaskByInstance.set(instance, task);
+	}
+	detachInstanceFromQueuedTasks(instance, exceptTask) {
+		const task = this.queuedTaskByInstance.get(instance);
+		if (task == null || task === exceptTask) return;
+		this.queuedTaskByInstance.delete(instance);
+		this.detachInstanceFromRenderTask(task, instance);
+		if (!task.primeCache && task.instances.size === 0) this.removeQueuedTask(task);
+	}
+	detachInstanceFromRenderTask(task, instance) {
+		if (task.type === "file") task.instances.delete(instance);
+		else task.instances.delete(instance);
+	}
+	removeQueuedTask(task) {
+		const index = this.queuedTasks.indexOf(task);
+		if (index !== -1) this.queuedTasks.splice(index, 1);
+		this.clearQueuedInstanceRequests(task);
+		this.clearHighlightKey(task);
+	}
+	removeActiveTask(task) {
+		this.clearInstanceRequests(task);
+		this.clearHighlightKey(task);
+		this.activeTaskById.delete(task.id);
+	}
+	clearQueuedInstanceRequests(task) {
+		for (const instance of getInstances(task)) if (this.queuedTaskByInstance.get(instance) === task) this.queuedTaskByInstance.delete(instance);
+	}
+	clearHighlightKey(task) {
+		if (task.highlightKey != null && this.taskByHighlightKey.get(task.highlightKey) === task) this.taskByHighlightKey.delete(task.highlightKey);
+	}
+	trackInstanceRequests(task) {
+		for (const instance of getInstances(task)) this.activeRequestByInstance.set(instance, task.id);
+	}
+	clearInstanceRequests(task) {
+		for (const instance of getInstances(task)) if (this.activeRequestByInstance.get(instance) === task.id) this.activeRequestByInstance.delete(instance);
+	}
+	notifyFileInstances(task, result, options) {
+		for (const instance of task.instances) if (this.activeRequestByInstance.get(instance) === task.id) instance.onHighlightSuccess(task.request.file, result, options);
+	}
+	notifyDiffInstances(task, result, options) {
+		for (const instance of task.instances) if (this.activeRequestByInstance.get(instance) === task.id) instance.onHighlightSuccess(task.request.diff, result, options);
+	}
+	notifyHighlightError(task, error) {
+		for (const instance of getInstances(task)) if (this.activeRequestByInstance.get(instance) === task.id) instance.onHighlightError(error);
+	}
+	hasMatchingFileInstanceTask(instance, file) {
+		for (const task of this.iterateRenderTasks()) if (task.type === "file" && task.instances.has(instance) && areFilesEqual(file, task.request.file)) return true;
+		return false;
+	}
+	hasMatchingDiffInstanceTask(instance, diff) {
+		for (const task of this.iterateRenderTasks()) if (task.type === "diff" && task.instances.has(instance) && areDiffTargetsEqual(task.request.diff, diff)) return true;
+		return false;
+	}
+	getTaskByHighlightKey(highlightKey) {
+		return this.taskByHighlightKey.get(highlightKey);
+	}
+	*iterateRenderTasks() {
+		for (const task of this.queuedTasks) yield task;
+		for (const task of this.activeTaskById.values()) if (isRenderTask(task)) yield task;
+	}
 	generateRequestId() {
 		return `req_${++this.nextRequestId}`;
 	}
@@ -587,6 +780,12 @@ function getLangsFromTask(task) {
 	langs.delete("text");
 	return Array.from(langs);
 }
+function isRenderTask(task) {
+	return task?.type === "file" || task?.type === "diff";
+}
+function getInstances(task) {
+	return task.instances;
+}
 
 //#endregion
 export { WorkerPoolManager };