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(