@marko/language-server 1.0.15 → 1.0.16

package/dist/index.mjs

@@ -754,73 +754,136 @@ var doComplete = async (doc, params) => {
 import path4 from "path";
 import { Project as Project2 } from "@marko/language-tools";
 import { DiagnosticSeverity } from "vscode-languageserver";
+import { DiagnosticType } from "@marko/babel-utils";
 var markoErrorRegExp = /^(.+?)\.marko(?:\((\d+)(?:\s*,\s*(\d+))?\))?: (.*)$/gm;
 var doValidate = (doc) => {
   const filename = getFSPath(doc);
   const diagnostics = [];
   try {
-    Project2.getCompiler(filename && path4.dirname(filename)).compileSync(
-      doc.getText(),
-      filename || "untitled.marko",
-      {
-        code: false,
-        output: "source",
-        sourceMaps: false,
-        babelConfig: {
-          caller: {
-            name: "@marko/language-server",
-            supportsStaticESM: true,
-            supportsDynamicImport: true,
-            supportsTopLevelAwait: true,
-            supportsExportNamespaceFrom: true
-          }
+    const { meta } = Project2.getCompiler(
+      filename && path4.dirname(filename)
+    ).compileSync(doc.getText(), filename || "untitled.marko", {
+      code: false,
+      output: "migrate",
+      sourceMaps: false,
+      errorRecovery: true,
+      babelConfig: {
+        caller: {
+          name: "@marko/language-server",
+          supportsStaticESM: true,
+          supportsDynamicImport: true,
+          supportsTopLevelAwait: true,
+          supportsExportNamespaceFrom: true
         }
       }
-    );
-  } catch (err) {
-    if (isErrorWithLoc(err)) {
-      const message = err.label || err.message || err.stack;
-      if (!message)
-        return;
-      const { loc } = err;
-      diagnostics.push({
-        range: {
+    });
+    if (meta.diagnostics) {
+      for (const diag of meta.diagnostics) {
+        const range = diag.loc ? {
           start: {
-            line: loc.start.line - 1,
-            character: loc.start.column
+            line: diag.loc.start.line - 1,
+            character: diag.loc.start.column
           },
           end: {
-            line: loc.end.line - 1,
-            character: loc.end.column
+            line: diag.loc.end.line - 1,
+            character: diag.loc.end.column
           }
-        },
-        source: "marko",
-        code: void 0,
-        tags: void 0,
-        severity: DiagnosticSeverity.Error,
-        message
-      });
-    } else {
-      let match;
-      while (match = markoErrorRegExp.exec(err.message)) {
-        const [, , rawLine, rawCol, message] = match;
-        const pos = {
-          line: (parseInt(rawLine, 10) || 1) - 1,
-          character: (parseInt(rawCol, 10) || 1) - 1
+        } : {
+          start: { line: 0, character: 0 },
+          end: { line: 0, character: 0 }
         };
+        let severity;
+        switch (diag.type) {
+          case DiagnosticType.Warning:
+          case DiagnosticType.Deprecation:
+            severity = DiagnosticSeverity.Warning;
+            break;
+          case DiagnosticType.Suggestion:
+            severity = DiagnosticSeverity.Hint;
+            break;
+          default:
+            severity = DiagnosticSeverity.Error;
+            break;
+        }
         diagnostics.push({
-          range: { start: pos, end: pos },
+          range,
           source: "marko",
           code: void 0,
           tags: void 0,
-          severity: DiagnosticSeverity.Error,
-          message
+          severity,
+          message: diag.label
         });
       }
     }
+  } catch (err) {
+    addDiagnosticsForError(err, diagnostics);
   }
   return diagnostics;
 };
+function addDiagnosticsForError(err, diagnostics) {
+  if (!isError(err)) {
+    diagnostics.push({
+      range: {
+        start: { line: 0, character: 0 },
+        end: { line: 0, character: 0 }
+      },
+      source: "marko",
+      code: void 0,
+      tags: void 0,
+      severity: DiagnosticSeverity.Error,
+      message: String(err)
+    });
+  } else if (isAggregateError(err)) {
+    for (const nestedError of err.errors) {
+      addDiagnosticsForError(nestedError, diagnostics);
+    }
+  } else if (isErrorWithLoc(err)) {
+    const message = err.label || err.message || err.stack;
+    if (!message)
+      return;
+    const { loc } = err;
+    diagnostics.push({
+      range: {
+        start: {
+          line: loc.start.line - 1,
+          character: loc.start.column
+        },
+        end: {
+          line: loc.end.line - 1,
+          character: loc.end.column
+        }
+      },
+      source: "marko",
+      code: void 0,
+      tags: void 0,
+      severity: DiagnosticSeverity.Error,
+      message
+    });
+  } else {
+    let match;
+    while (match = markoErrorRegExp.exec(err.message)) {
+      const [, , rawLine, rawCol, message] = match;
+      const pos = {
+        line: (parseInt(rawLine, 10) || 1) - 1,
+        character: (parseInt(rawCol, 10) || 1) - 1
+      };
+      diagnostics.push({
+        range: { start: pos, end: pos },
+        source: "marko",
+        code: void 0,
+        tags: void 0,
+        severity: DiagnosticSeverity.Error,
+        message
+      });
+    }
+  }
+}
+function isError(err) {
+  return err != null && typeof err === "object" && typeof err.message === "string";
+}
+function isAggregateError(err) {
+  return Array.isArray(err == null ? void 0 : err.errors);
+}
 function isErrorWithLoc(err) {
   const loc = err == null ? void 0 : err.loc;
   if (typeof loc !== "object")