@pierre/diffs 1.5.1 → 1.6.0-beta.1

package/dist/worker/WorkerPoolManager.js

@@ -1,14 +1,14 @@
 import { DEFAULT_THEMES } from "../constants.js";
-import { areLanguagesAttached } from "../highlighter/languages/areLanguagesAttached.js";
+import { HighlighterDisposedError, resolveHighlighterType } from "../highlighter/highlighterType.js";
 import { getThemes } from "../utils/getThemes.js";
-import { attachResolvedThemes } from "../highlighter/themes/attachResolvedThemes.js";
-import { getSharedHighlighter } from "../highlighter/shared_highlighter.js";
+import { getHighlighterIfLoaded, getSharedHighlighter } from "../highlighter/shared_highlighter.js";
 import { areThemesEqual } from "../utils/areThemesEqual.js";
-import { hasResolvedThemes } from "../highlighter/themes/hasResolvedThemes.js";
+import { areLanguagesAttached } from "../highlighter/languages/areLanguagesAttached.js";
 import { areFileRenderOptionsEqual } from "../utils/areFileRenderOptionsEqual.js";
 import { getCustomExtensionsMap, getCustomExtensionsVersion, getFiletypeFromFileName } from "../utils/getFiletypeFromFileName.js";
 import { isFilePlainText } from "../utils/isFilePlainText.js";
 import { renderFileWithHighlighter } from "../utils/renderFileWithHighlighter.js";
+import { WorkerPoolTaskCanceledError, WorkerPoolTerminatedError, WorkerPoolWorkerError, isHandledWorkerPoolError, markWorkerErrorReported } from "./errors.js";
 import { areDiffTargetsEqual } from "../utils/areDiffTargetsEqual.js";
 import { areFilesEqual } from "../utils/areFilesEqual.js";
 import { areDiffRenderOptionsEqual } from "../utils/areDiffRenderOptionsEqual.js";
@@ -18,24 +18,15 @@ import { getResolvedLanguages } from "../highlighter/languages/getResolvedLangua
 import { hasResolvedLanguages } from "../highlighter/languages/hasResolvedLanguages.js";
 import { resolveLanguages } from "../highlighter/languages/resolveLanguages.js";
 import { getResolvedThemes } from "../highlighter/themes/getResolvedThemes.js";
+import { hasResolvedThemes } from "../highlighter/themes/hasResolvedThemes.js";
 import { resolveThemes } from "../highlighter/themes/resolveThemes.js";
+import { decodeHastLines } from "./hastLinesTransport.js";
 import LRUMapPkg from "lru_map";
 //#region src/worker/WorkerPoolManager.ts
 const IGNORE_RESPONSE = Symbol("IGNORE_RESPONSE");
 const DEFAULT_WORKER_INITIALIZATION_TIMEOUT = 1e4;
-var WorkerPoolTerminatedError = class extends Error {
-	constructor() {
-		super("WorkerPoolManager: operation canceled because the pool terminated");
-	}
-};
-var WorkerPoolTaskCanceledError = class extends Error {
-	constructor() {
-		super("WorkerPoolManager: operation canceled before the task completed");
-	}
-};
 var WorkerPoolManager = class {
 	options;
-	highlighter;
 	preferredHighlighter;
 	renderOptions;
 	renderOptionsRequestVersion = 0;
@@ -55,9 +46,9 @@ var WorkerPoolManager = class {
 	diffCache;
 	_queuedBroadcast;
 	lifecycleGeneration = 0;
-	constructor(options, { langs, theme = DEFAULT_THEMES, useTokenTransformer = false, lineDiffType = "word-alt", maxLineDiffLength = 1e3, tokenizeMaxLineLength = 1e3, preferredHighlighter = "shiki-js" }) {
+	constructor(options, { langs, theme = DEFAULT_THEMES, useTokenTransformer = false, lineDiffType = "word-alt", maxLineDiffLength = 1e3, tokenizeMaxLineLength = 1e3, preferredHighlighter }) {
 		this.options = options;
-		this.preferredHighlighter = preferredHighlighter;
+		this.preferredHighlighter = resolveHighlighterType(preferredHighlighter);
 		this.renderOptions = {
 			theme,
 			useTokenTransformer,
@@ -115,20 +106,11 @@ var WorkerPoolManager = class {
 			if (!isCurrentRequest() || areDiffRenderOptionsEqual(newRenderOptions, this.renderOptions)) return;
 			const themeNames = getThemes(theme);
 			let resolvedThemes = [];
-			if (!areThemesEqual(newRenderOptions.theme, this.renderOptions.theme)) {
-				if (hasResolvedThemes(themeNames)) resolvedThemes = getResolvedThemes(themeNames);
-				else resolvedThemes = await resolveThemes(themeNames);
-			}
+			if (!areThemesEqual(newRenderOptions.theme, this.renderOptions.theme)) resolvedThemes = hasResolvedThemes(themeNames, this.preferredHighlighter) ? getResolvedThemes(themeNames, this.preferredHighlighter) : await resolveThemes(themeNames, this.preferredHighlighter);
 			if (!isCurrentRequest()) return;
-			if (this.highlighter != null) attachResolvedThemes(resolvedThemes, this.highlighter);
-			else {
-				const highlighter = await getSharedHighlighter({
-					themes: themeNames,
-					langs: ["text"],
-					preferredHighlighter: this.preferredHighlighter
-				});
+			if (getHighlighterIfLoaded({ theme }) == null) {
+				await this.loadSharedHighlighter(themeNames, ["text"]);
 				if (!isCurrentRequest()) return;
-				this.highlighter = highlighter;
 			}
 			const workerSetup = this.setRenderOptionsOnWorkers(newRenderOptions, resolvedThemes);
 			this.renderOptions = newRenderOptions;
@@ -236,38 +218,32 @@ var WorkerPoolManager = class {
 		return this.initialized === true;
 	}
 	async initialize(languages = []) {
-		if (this.initialized === true) return;
-		else if (this.initialized === false) {
+		if (this.initialized === true) {
+			if (getHighlighterIfLoaded({ theme: this.renderOptions.theme }) == null) await this.loadSharedHighlighter(getThemes(this.renderOptions.theme), ["text", ...languages]);
+			return;
+		} else if (this.initialized === false) {
 			const { lifecycleGeneration } = this;
-			this.initialized = new Promise((resolve, reject) => {
+			const initialization = new Promise((resolve, reject) => {
 				(async () => {
 					try {
 						const themes = getThemes(this.renderOptions.theme);
-						let resolvedThemes = [];
-						if (hasResolvedThemes(themes)) resolvedThemes = getResolvedThemes(themes);
-						else resolvedThemes = await resolveThemes(themes);
+						const resolvedThemes = hasResolvedThemes(themes, this.preferredHighlighter) ? getResolvedThemes(themes, this.preferredHighlighter) : await resolveThemes(themes, this.preferredHighlighter);
 						if (!this.isCurrentLifecycle(lifecycleGeneration)) {
 							resolve();
 							return;
 						}
 						let resolvedLanguages = [];
-						if (hasResolvedLanguages(languages)) resolvedLanguages = getResolvedLanguages(languages);
-						else resolvedLanguages = await resolveLanguages(languages);
+						if (this.preferredHighlighter !== "highlights") resolvedLanguages = hasResolvedLanguages(languages) ? getResolvedLanguages(languages) : await resolveLanguages(languages);
 						if (!this.isCurrentLifecycle(lifecycleGeneration)) {
 							resolve();
 							return;
 						}
-						const [highlighter] = await Promise.all([getSharedHighlighter({
-							themes,
-							langs: ["text", ...languages],
-							preferredHighlighter: this.preferredHighlighter
-						}), this.initializeWorkers(resolvedThemes, resolvedLanguages)]);
+						await Promise.all([this.loadSharedHighlighter(themes, ["text", ...languages]), this.initializeWorkers(resolvedThemes, resolvedLanguages)]);
 						if (!this.isCurrentLifecycle(lifecycleGeneration)) {
 							this.terminateWorkers();
 							resolve();
 							return;
 						}
-						this.highlighter = highlighter;
 						this.initialized = true;
 						this.diffCache.clear();
 						this.fileCache.clear();
@@ -290,9 +266,22 @@ var WorkerPoolManager = class {
 					}
 				})();
 			});
+			this.initialized = initialization;
 			this.queueBroadcastStateChanges();
+			return initialization;
 		} else return this.initialized;
 	}
+	async loadSharedHighlighter(themes, langs) {
+		try {
+			await getSharedHighlighter({
+				themes,
+				langs,
+				preferredHighlighter: this.preferredHighlighter
+			});
+		} catch (error) {
+			if (!(error instanceof HighlighterDisposedError)) throw error;
+		}
+	}
 	async initializeWorkers(resolvedThemes, resolvedLanguages) {
 		this.workersFailed = false;
 		const initPromises = [];
@@ -321,6 +310,7 @@ var WorkerPoolManager = class {
 					id,
 					request: {
 						type: "initialize",
+						resultFormat: "hast-ops-v1",
 						id,
 						renderOptions: this.renderOptions,
 						preferredHighlighter: this.preferredHighlighter,
@@ -353,13 +343,29 @@ var WorkerPoolManager = class {
 			if (timeoutId != null) clearTimeout(timeoutId);
 		}
 	}
-	handleWorkerError(managedWorker, error) {
-		console.error("Worker error:", error, managedWorker);
+	/**
+	* Pass worker errors to onWorkerError, or log them if no callback is set.
+	*
+	* A startup error rejects initialization so components can highlight on the
+	* main thread. Other requests wait for their own responses: worker.ts catches
+	* request errors, so this event may be unrelated to the current request.
+	* A worker that stops responding remains busy and receives no further work.
+	*/
+	handleWorkerError(managedWorker, event) {
+		const { onWorkerError } = this.options;
+		if (onWorkerError != null) try {
+			onWorkerError(event, managedWorker.worker);
+		} catch (hookError) {
+			console.error("WorkerPoolManager: onWorkerError threw:", hookError);
+		}
+		else console.error("Worker error:", event, managedWorker);
 		const { pendingSetupRequestId } = managedWorker;
 		if (pendingSetupRequestId == null) return;
 		const task = this.activeTaskById.get(pendingSetupRequestId);
 		if (task?.type !== "initialize") return;
-		task.reject(normalizeWorkerError(error));
+		const error = errorFromWorkerErrorEvent(event);
+		if (onWorkerError != null) markWorkerErrorReported(error);
+		task.reject(error);
 		this.cleanWorkerAndTask(managedWorker, task);
 	}
 	drainQueue = () => {
@@ -414,11 +420,12 @@ var WorkerPoolManager = class {
 		}
 	}
 	getPlainFileAST(file, startingLine, totalLines, lines) {
-		if (this.highlighter == null) {
+		const highlighter = getHighlighterIfLoaded({ theme: this.renderOptions.theme });
+		if (highlighter == null) {
 			this.queueInitialization();
 			return;
 		}
-		return renderFileWithHighlighter(file, this.highlighter, this.renderOptions, {
+		return renderFileWithHighlighter(file, highlighter, this.renderOptions, {
 			forcePlainText: true,
 			startingLine,
 			totalLines,
@@ -459,13 +466,18 @@ var WorkerPoolManager = class {
 		}
 	}
 	getPlainDiffAST(diff, startingLine, totalLines, expandedHunks, collapsedContextThreshold) {
-		return this.highlighter != null ? renderDiffWithHighlighter(diff, this.highlighter, this.renderOptions, {
+		const highlighter = getHighlighterIfLoaded({ theme: this.renderOptions.theme });
+		if (highlighter == null) {
+			this.queueInitialization();
+			return;
+		}
+		return renderDiffWithHighlighter(diff, highlighter, this.renderOptions, {
 			forcePlainText: true,
 			startingLine,
 			totalLines,
 			expandedHunks,
 			collapsedContextThreshold
-		}) : void 0;
+		});
 	}
 	terminate() {
 		this.lifecycleGeneration++;
@@ -480,7 +492,6 @@ var WorkerPoolManager = class {
 		this.queuedTaskByInstance.clear();
 		this.taskByHighlightKey.clear();
 		this.activeTaskById.clear();
-		this.highlighter = void 0;
 		this.initialized = false;
 		this.workersFailed = false;
 		this.queueBroadcastStateChanges();
@@ -490,6 +501,7 @@ var WorkerPoolManager = class {
 	}
 	queueInitialization(languages) {
 		this.initialize(languages).catch((error) => {
+			if (isHandledWorkerPoolError(error)) return;
 			console.error(error);
 		});
 	}
@@ -615,15 +627,12 @@ var WorkerPoolManager = class {
 	}
 	async resolveLanguagesAndExecuteTask(availableWorker, task, langs) {
 		try {
-			const mainThreadLangs = langs.filter((lang) => !areLanguagesAttached(lang));
-			if (mainThreadLangs.length > 0) getSharedHighlighter({
-				themes: getThemes(this.renderOptions.theme),
-				langs: ["text", ...mainThreadLangs],
-				preferredHighlighter: this.preferredHighlighter
-			}).catch((error) => {
+			const highlighter = getHighlighterIfLoaded();
+			const mainThreadLangs = langs.filter((lang) => highlighter == null || !areLanguagesAttached(lang, highlighter));
+			if (mainThreadLangs.length > 0) this.loadSharedHighlighter(getThemes(this.renderOptions.theme), ["text", ...mainThreadLangs]).catch((error) => {
 				console.error(error);
 			});
-			const workerMissingLangs = langs.filter((lang) => !availableWorker.langs.has(lang));
+			const workerMissingLangs = this.preferredHighlighter === "highlights" ? [] : 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);
@@ -671,9 +680,13 @@ var WorkerPoolManager = class {
 						break;
 					case "file": {
 						if (task.type !== "file") throw new Error("handleWorkerMessage: task/response dont match");
-						const { result, options } = response;
+						const { options } = response;
 						if (!this.isCurrentRenderTask(task) || !areFileRenderOptionsEqual(options, this.getFileRenderOptions())) throw IGNORE_RESPONSE;
 						const { request } = task;
+						const result = {
+							...response.result,
+							code: decodeHastLines(response.result.code)
+						};
 						this.syncCustomExtensionVersion(managedWorker, request);
 						if (task.cacheKeyAtDispatch != null) this.fileCache.set(task.cacheKeyAtDispatch, {
 							result,
@@ -685,9 +698,16 @@ var WorkerPoolManager = class {
 					}
 					case "diff": {
 						if (task.type !== "diff") throw new Error("handleWorkerMessage: task/response dont match");
-						const { result, options } = response;
+						const { options } = response;
 						if (!this.isCurrentRenderTask(task) || !areDiffRenderOptionsEqual(options, this.getDiffRenderOptions())) throw IGNORE_RESPONSE;
 						const { request } = task;
+						const result = {
+							...response.result,
+							code: {
+								deletionLines: decodeHastLines(response.result.code.deletionLines),
+								additionLines: decodeHastLines(response.result.code.additionLines)
+							}
+						};
 						this.syncCustomExtensionVersion(managedWorker, request);
 						if (task.cacheKeyAtDispatch != null) this.diffCache.set(task.cacheKeyAtDispatch, {
 							result,
@@ -922,6 +942,11 @@ function normalizeWorkerError(error) {
 	}
 	return new Error(String(error));
 }
+function errorFromWorkerErrorEvent(event) {
+	const cause = "error" in event ? event.error : void 0;
+	const message = "message" in event && typeof event.message === "string" && event.message !== "" ? event.message : cause instanceof Error ? cause.message : "the worker script failed to load (the error event carries no message)";
+	return new WorkerPoolWorkerError(`WorkerPoolManager: worker failed: ${message}`, cause instanceof Error ? { cause } : void 0);
+}
 //#endregion
 export { WorkerPoolManager };