From ece1862fae9c3385e3131df6b856457e1e120f93 Mon Sep 17 00:00:00 2001
From: Slinetrac <realakayuki@gmail.com>
Date: Fri, 13 Mar 2026 15:28:15 +0800
Subject: [PATCH] refactor: monaco init (#6496)

---
 src/main.tsx                      | 14 ---------
 src/utils/monaco-worker-ignore.ts | 38 ----------------------
 src/utils/monaco.ts               | 52 ++++++++++++++-----------------
 3 files changed, 23 insertions(+), 81 deletions(-)
 delete mode 100644 src/utils/monaco-worker-ignore.ts

diff --git a/src/main.tsx b/src/main.tsx
index f48a4a183..6680f8812 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -26,10 +26,6 @@ import {
   UpdateStateProvider,
 } from "./services/states";
 import { disableWebViewShortcuts } from "./utils/disable-webview-shortcuts";
-import {
-  isIgnoredMonacoWorkerError,
-  patchMonacoWorkerConsole,
-} from "./utils/monaco-worker-ignore";
 
 if (!window.ResizeObserver) {
   window.ResizeObserver = ResizeObserver;
@@ -91,22 +87,12 @@ bootstrap().catch((error) => {
     });
 });
 
-patchMonacoWorkerConsole();
-
 // Error handling
 window.addEventListener("error", (event) => {
-  if (isIgnoredMonacoWorkerError(event.error ?? event.message)) {
-    event.preventDefault();
-    return;
-  }
   console.error("[main.tsx] Global error:", event.error);
 });
 
 window.addEventListener("unhandledrejection", (event) => {
-  if (isIgnoredMonacoWorkerError(event.reason)) {
-    event.preventDefault();
-    return;
-  }
   console.error("[main.tsx] Unhandled promise rejection:", event.reason);
 });
 
diff --git a/src/utils/monaco-worker-ignore.ts b/src/utils/monaco-worker-ignore.ts
deleted file mode 100644
index 980158d17..000000000
--- a/src/utils/monaco-worker-ignore.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-// These warnings are safe to ignore: they occur when Monaco models or workers are manually disposed.
-const ignoredGlobalErrorMessages = [
-  "Missing requestHandler or method:",
-  "Could not create web worker(s). Falling back to loading web worker code in main thread",
-  "Cannot use 'in' operator to search for 'then' in undefined",
-];
-
-const isIgnoredMessage = (message: string) =>
-  ignoredGlobalErrorMessages.some((snippet) => message.includes(snippet));
-
-export const isIgnoredMonacoWorkerError = (reason: unknown) => {
-  const message = String(
-    reason instanceof Error ? reason.message : (reason ?? ""),
-  );
-  return isIgnoredMessage(message);
-};
-
-const shouldIgnoreConsoleArgs = (args: unknown[]) =>
-  args.some((arg) => {
-    const message =
-      typeof arg === "string" ? arg : arg instanceof Error ? arg.message : "";
-    return isIgnoredMessage(message);
-  });
-
-export const patchMonacoWorkerConsole = () => {
-  const originalWarn = console.warn;
-  const originalError = console.error;
-
-  console.warn = (...args) => {
-    if (shouldIgnoreConsoleArgs(args)) return;
-    originalWarn(...args);
-  };
-
-  console.error = (...args) => {
-    if (shouldIgnoreConsoleArgs(args)) return;
-    originalError(...args);
-  };
-};
diff --git a/src/utils/monaco.ts b/src/utils/monaco.ts
index e71b03cf6..662f0b4cd 100644
--- a/src/utils/monaco.ts
+++ b/src/utils/monaco.ts
@@ -5,40 +5,34 @@ import cssWorker from "monaco-editor/esm/vs/language/css/css.worker?worker";
 import tsWorker from "monaco-editor/esm/vs/language/typescript/ts.worker?worker";
 import yamlWorker from "monaco-yaml/yaml.worker?worker";
 
-type WorkerConstructor = new () => Worker;
-
-// Ensure monaco loader uses the bundled ESM instance instead of CDN.
-loader.config({ monaco });
-
-// Align with the former plugin mapping so Monaco can resolve its background workers.
-const workerConstructors: Record<string, WorkerConstructor> = {
-  editorWorkerService: editorWorker,
-  typescript: tsWorker,
-  javascript: tsWorker,
-  "languages.typescript": tsWorker,
-  css: cssWorker,
-  less: cssWorker,
-  scss: cssWorker,
-  "languages.css": cssWorker,
-  yaml: yamlWorker,
-};
-
-const defaultWorker = workerConstructors.editorWorkerService;
-
-if (typeof window !== "undefined") {
+if (typeof self !== "undefined") {
   const globalScope = self as typeof self & {
     MonacoEnvironment?: {
-      getWorker: (moduleId: string, label: string) => Worker;
+      getWorker: (workerId: string, label: string) => Worker;
     };
   };
 
-  const getWorker = (_moduleId: string, label: string) => {
-    const WorkerCtor = workerConstructors[label] ?? defaultWorker;
-    return new WorkerCtor();
-  };
-
   globalScope.MonacoEnvironment = {
-    ...globalScope.MonacoEnvironment,
-    getWorker,
+    getWorker(_workerId: string, label: string) {
+      switch (label) {
+        case "css":
+        case "less":
+        case "scss":
+          return new cssWorker();
+        case "typescript":
+        case "javascript":
+          return new tsWorker();
+        case "yaml":
+          return new yamlWorker();
+        default:
+          return new editorWorker();
+      }
+    },
   };
 }
+
+loader.config({ monaco });
+
+void loader.init().catch((error: unknown) => {
+  console.error("[monaco] Monaco initialization failed:", error);
+});