@lvce-editor/editor-worker 19.69.10 → 19.70.0

package/dist/editorWorkerMain.js

@@ -6438,7 +6438,11 @@ const saveProviderResults = (editor, providers) => {
     uri: editor.uri
   });
 };
-const updateDiagnostics = async editor => {
+const updateDiagnostics = async (editor, timeoutMs = 0) => {
+  const strict = timeoutMs > 0;
+  if (strict && editor.loadError) {
+    throw new Error(`Cannot await diagnostics: ${editor.loadError}`);
+  }
   if (!editor.diagnosticsEnabled || editor.loadError) {
     return editor;
   }
@@ -6459,13 +6463,22 @@ const updateDiagnostics = async editor => {
   const completed = Promise.withResolvers();
   let commitQueue = Promise.resolve();
   let providerCount = -1;
+  let finished = false;
+  const receivedProviders = new Set();
+  const timeout = strict ? setTimeout(() => completed.reject(new Error(`Diagnostics timed out after ${timeoutMs}ms for ${editor.uri}`)), timeoutMs) : undefined;
   port1.onmessage = event => {
     const previousCommit = commitQueue;
     commitQueue = (async () => {
       await previousCommit;
       try {
+        if (finished) {
+          return;
+        }
         const message = event.data;
         if (requestGenerations.get(editor.id) !== generation) {
+          if (strict) {
+            throw new Error('Diagnostics request was superseded');
+          }
           if (message.type === 'done') {
             port1.close();
             completed.resolve();
@@ -6492,6 +6505,10 @@ const updateDiagnostics = async editor => {
           return;
         }
         if (message.type === 'result' && message.providerId !== undefined) {
+          if (strict && message.error !== undefined) {
+            throw new Error(`Diagnostic provider ${message.providerId} failed: ${message.error}`);
+          }
+          receivedProviders.add(message.providerId);
           providers.set(message.providerId, {
             diagnostics: message.diagnostics ?? [],
             providerIndex: message.providerIndex ?? providers.size
@@ -6500,6 +6517,9 @@ const updateDiagnostics = async editor => {
           return;
         }
         if (message.type === 'done') {
+          if (strict && (providerCount < 0 || receivedProviders.size !== providerCount)) {
+            throw new Error('Diagnostics stream ended without all provider results');
+          }
           if (providerCount === 0) {
             providers.clear();
             await commitDiagnostics(editor, generation, [], () => saveProviderResults(editor, providers));
@@ -6512,15 +6532,25 @@ const updateDiagnostics = async editor => {
         }
       } catch (error) {
         port1.close();
-        completed.resolve();
-        await handleError(error, editor);
+        if (strict) {
+          completed.reject(error);
+        } else {
+          completed.resolve();
+          await handleError(error, editor);
+        }
       }
     })();
   };
   port1.start();
-  try {
+  const request = async () => {
     const response = await getDiagnostics$1(editor, port2);
+    if (finished) {
+      return;
+    }
     if (Array.isArray(response) && providerCount === -1) {
+      if (strict) {
+        throw new Error('Diagnostic provider does not support completion and error reporting');
+      }
       providers.set('legacy', {
         diagnostics: response,
         providerIndex: 0
@@ -6529,12 +6559,27 @@ const updateDiagnostics = async editor => {
       port1.close();
       completed.resolve();
     }
-    await completed.promise;
+  };
+  try {
+    await Promise.all([request(), completed.promise]);
     const latest = get$8(editor.id);
+    if (strict && !isApplicable(latest, editor, generation)) {
+      throw new Error('Editor changed or closed while waiting for diagnostics');
+    }
     return isApplicable(latest, editor, generation) ? latest.newState : editor;
   } catch (error) {
-    port1.close();
+    if (strict) {
+      if (requestGenerations.get(editor.id) === generation) {
+        requestGenerations.set(editor.id, generation + 1);
+      }
+      throw error;
+    }
     return handleError(error, editor);
+  } finally {
+    finished = true;
+    clearTimeout(timeout);
+    port1.close();
+    port2.close();
   }
 };
 const requestDiagnostics = editor => {
@@ -6555,6 +6600,18 @@ const updateDiagnosticsAll = async () => {
   }
 };
 
+// Do not wrap this command in EditorCommandQueue: streamed results need that queue to commit.
+const waitForDiagnostics = async (editorId, timeoutMs = 30_000) => {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 300_000) {
+    throw new Error('Diagnostics timeout must be between 1 and 300000ms');
+  }
+  const editor = get$8(editorId)?.newState;
+  if (!editor || editor.initial) {
+    throw new Error(`Editor is not ready: ${editorId}`);
+  }
+  await updateDiagnostics(editor, timeoutMs);
+};
+
 const disposeEditor = async editorUid => {
   const editor = get$8(editorUid)?.newState;
   if (!editor) {
@@ -18264,6 +18321,7 @@ const commandMap = {
   'Editor.updateDebugInfo': updateDebugInfo,
   'Editor.updateDiagnostics': wrapCommand(requestDiagnostics),
   'Editor.updateDiagnosticsAll': updateDiagnosticsAll,
+  'Editor.waitForDiagnostics': waitForDiagnostics,
   'EditorCompletion.close': close$3,
   'EditorCompletion.closeDetails': closeDetails$1,
   'EditorCompletion.focusFirst': focusFirst$1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/editor-worker",
-  "version": "19.69.10",
+  "version": "19.70.0",
   "repository": {
     "type": "git",
     "url": "git@github.com:lvce-editor/editor-worker.git"