From e601af782031bcdf50f40675f2eba1ba9b6624d9 Mon Sep 17 00:00:00 2001 From: Alex Sorafumo Date: Mon, 2 Nov 2026 09:15:43 +1100 Subject: [PATCH] fix(monaco): stop reporting worker load errors after an editor closes Monaco stops its editor worker when the last model closes, for example when the user opens a different system. If the worker script is still loading, Chrome raises a failed importScripts NetworkError on the window. Monaco removed its own listener first, so Angular sent the error to Sentry as unhandled. Wrap MonacoEnvironment.getWorker so each worker cancels its error events after terminate(). Errors from workers that still run are not changed. Fixes BACKOFFICE-4Q Co-Authored-By: Claude Opus 5.5 --- src/app/common/monaco.ts | 39 ++++++++++++++++++++++++++++++++- src/tests/common/monaco.spec.ts | 21 ++++++++++++++++++ 2 files changed, 59 insertions(+), 1 deletion(-) diff --git a/src/app/common/monaco.ts b/src/app/common/monaco.ts index 57cfddea7..1d9e2c0f3 100644 --- a/src/app/common/monaco.ts +++ b/src/app/common/monaco.ts @@ -19,6 +19,36 @@ declare global { let loading: Promise | undefined; +/** + * Stop errors from editor workers that Monaco already stopped. + * Monaco stops its worker when the last model closes, for example when the + * user leaves a page with an editor. If the worker script is still loading, + * the browser then reports a failed `importScripts` on the window. Monaco + * removed its own listener first, so the error was unhandled. Errors from + * workers that still run are not changed. + */ +export function ignoreStoppedWorkerErrors( + environment: monaco.Environment | undefined, +) { + const getWorker = environment?.getWorker; + if (!getWorker) return; + environment.getWorker = (worker_id, label) => { + const worker = getWorker.call(environment, worker_id, label); + void Promise.resolve(worker).then((created) => { + let stopped = false; + const terminate = created.terminate.bind(created); + created.terminate = () => { + stopped = true; + terminate(); + }; + created.addEventListener('error', (event) => { + if (stopped) event.preventDefault(); + }); + }); + return worker; + }; +} + /** Share one editor download across fields and allow retry after a failed load. */ export function loadMonaco(): Promise { if (loading) return loading; @@ -51,7 +81,14 @@ export function loadMonaco(): Promise { vs: new URL('assets/monaco/min/vs', document.baseURI).href, }, }); - loader(['vs/editor/editor.main'], () => finish(), finish); + loader( + ['vs/editor/editor.main'], + () => { + ignoreStoppedWorkerErrors(globalThis.MonacoEnvironment); + finish(); + }, + finish, + ); }; if (window.require) return loadEditor(); script.src = new URL( diff --git a/src/tests/common/monaco.spec.ts b/src/tests/common/monaco.spec.ts index 83d7085c7..420428274 100644 --- a/src/tests/common/monaco.spec.ts +++ b/src/tests/common/monaco.spec.ts @@ -63,6 +63,27 @@ describe('Monaco loading', () => { await second; }); + it('only stops errors from workers that Monaco stopped', async () => { + const { ignoreStoppedWorkerErrors } = + await import('../../app/common/monaco'); + const terminate = vi.fn(); + const worker = Object.assign(new EventTarget(), { + terminate, + }) as unknown as Worker; + const environment = { getWorker: () => worker }; + ignoreStoppedWorkerErrors(environment); + expect(environment.getWorker()).toBe(worker); + await Promise.resolve(); + const running = new Event('error', { cancelable: true }); + worker.dispatchEvent(running); + expect(running.defaultPrevented).toBe(false); + worker.terminate(); + expect(terminate).toHaveBeenCalledOnce(); + const stopped = new Event('error', { cancelable: true }); + worker.dispatchEvent(stopped); + expect(stopped.defaultPrevented).toBe(true); + }); + it('stops waiting when the editor does not respond', async () => { const { loadMonaco } = await import('../../app/common/monaco'); const failure = expect(loadMonaco()).rejects.toThrow(