typespec-vscode 0.57.0-dev.2 → 0.57.0-dev.3

package/dist/src/extension.cjs

@@ -21044,8 +21044,116 @@ var api = {};
 
 var node = main$3;
 
+const TRACE_PREFIX = /^\[Trace.*?\] /iu;
+const DEBUG_PREFIX = /^\[Debug.*?\] /iu;
+const INFO_PREFIX = /^\[Info.*?\] /iu;
+const WARN_PREFIX = /^\[Warn.*?\] /iu;
+const ERROR_PREFIX = /^\[Error.*?\] /iu;
+class TypeSpecLogOutputChannel {
+    delegate;
+    constructor(name) {
+        this.delegate = require$$0$1.window.createOutputChannel(name, { log: true });
+    }
+    get logLevel() {
+        return this.delegate.logLevel;
+    }
+    get onDidChangeLogLevel() {
+        return this.delegate.onDidChangeLogLevel;
+    }
+    trace(message, ...args) {
+        this.delegate.trace(message, ...args);
+    }
+    debug(message, ...args) {
+        this.delegate.debug(message, ...args);
+    }
+    info(message, ...args) {
+        this.delegate.info(message, ...args);
+    }
+    warn(message, ...args) {
+        this.delegate.warn(message, ...args);
+    }
+    error(error, ...args) {
+        this.delegate.error(error, ...args);
+    }
+    get name() {
+        return this.delegate.name;
+    }
+    replace(value) {
+        this.delegate.replace(value);
+    }
+    clear() {
+        this.delegate.clear();
+    }
+    show(column, preserveFocus) {
+        // eslint-disable-next-line deprecation/deprecation
+        this.delegate.show(column, preserveFocus);
+    }
+    hide() {
+        this.delegate.hide();
+    }
+    dispose() {
+        this.delegate.dispose();
+    }
+    append(value) {
+        this.logToDelegate(value);
+    }
+    appendLine(value) {
+        this.logToDelegate(value);
+    }
+    preLevel = "";
+    logToDelegate(value) {
+        if (TRACE_PREFIX.test(value)) {
+            this.preLevel = "trace";
+            this.delegate.trace(value.replace(TRACE_PREFIX, ""));
+        }
+        else if (DEBUG_PREFIX.test(value)) {
+            this.preLevel = "debug";
+            this.delegate.debug(value.replace(DEBUG_PREFIX, ""));
+        }
+        else if (INFO_PREFIX.test(value)) {
+            this.preLevel = "info";
+            this.delegate.info(value.replace(INFO_PREFIX, ""));
+        }
+        else if (WARN_PREFIX.test(value)) {
+            this.preLevel = "warning";
+            this.delegate.warn(value.replace(WARN_PREFIX, ""));
+        }
+        else if (ERROR_PREFIX.test(value)) {
+            this.preLevel = "error";
+            this.delegate.error(value.replace(ERROR_PREFIX, ""));
+        }
+        else {
+            // a msg sent without a level prefix should be because a message is sent by calling multiple appendLine()
+            // so just log it with the previous level
+            switch (this.preLevel) {
+                case "trace":
+                    this.delegate.trace(value);
+                    break;
+                case "debug":
+                    this.delegate.debug(value);
+                    break;
+                case "info":
+                    this.delegate.info(value);
+                    break;
+                case "warning":
+                    this.delegate.warn(value);
+                    break;
+                case "error":
+                    this.delegate.error(value);
+                    break;
+                default:
+                    this.delegate.debug(`Log Message with invalid log level (${this.preLevel}). Raw message: ${value}`);
+            }
+        }
+    }
+}
+
 let client;
-const outputChannel = require$$0$1.window.createOutputChannel("TypeSpec");
+/**
+ * Workaround: LogOutputChannel doesn't work well with LSP RemoteConsole, so having a customized LogOutputChannel to make them work together properly
+ * More detail can be found at https://github.com/microsoft/vscode-discussions/discussions/1149
+ */
+const outputChannel = new TypeSpecLogOutputChannel("TypeSpec");
 async function activate(context) {
     context.subscriptions.push(require$$0$1.commands.registerCommand("typespec.showOutputChannel", () => {
         outputChannel.show(true /*preserveFocus*/);
@@ -21060,10 +21168,12 @@ async function restartTypeSpecServer() {
     if (client) {
         await client.stop();
         await client.start();
+        outputChannel.debug("TypeSpec server restarted");
     }
 }
 async function launchLanguageClient(context) {
     const exe = await resolveTypeSpecServer(context);
+    outputChannel.debug("TypeSpec server resolved as ", exe);
     const options = {
         synchronize: {
             // Synchronize the setting section 'typespec' to the server
@@ -21083,20 +21193,22 @@ async function launchLanguageClient(context) {
         outputChannel,
     };
     const name = "TypeSpec";
-    const id = "typespecLanguageServer";
+    const id = "typespec";
     try {
         client = new node.LanguageClient(id, name, { run: exe, debug: exe }, options);
         await client.start();
+        outputChannel.debug("TypeSpec server started");
     }
     catch (e) {
         if (typeof e === "string" && e.startsWith("Launching server using command")) {
             const workspaceFolder = require$$0$1.workspace.workspaceFolders?.[0]?.uri?.fsPath ?? "";
-            client?.error([
+            outputChannel.error([
                 `TypeSpec server executable was not found: '${exe.command}' is not found. Make sure either:`,
                 ` - TypeSpec is installed locally at the root of this workspace ("${workspaceFolder}") or in a parent directory.`,
                 " - TypeSpec is installed globally with `npm install -g @typespec/compiler'.",
                 " - TypeSpec server path is configured with https://github.com/microsoft/typespec#installing-vs-code-extension.",
-            ].join("\n"), undefined, false);
+            ].join("\n"));
+            outputChannel.error("Error detail", e);
             throw `TypeSpec server executable was not found: '${exe.command}' is not found.`;
         }
         else {
@@ -21113,6 +21225,7 @@ async function resolveTypeSpecServer(context) {
         // we use CLI instead of NODE_OPTIONS environment variable in this case
         // because --nolazy is not supported by NODE_OPTIONS.
         const options = nodeOptions?.split(" ").filter((o) => o) ?? [];
+        outputChannel.debug("TypeSpec server resolved in development mode");
         return { command: "node", args: [...options, script, ...args] };
     }
     const options = {
@@ -21130,11 +21243,15 @@ async function resolveTypeSpecServer(context) {
     const workspaceFolder = require$$0$1.workspace.workspaceFolders?.[0]?.uri?.fsPath ?? "";
     // Default to tsp-server on PATH, which would come from `npm install -g
     // @typespec/compiler` in a vanilla setup.
-    if (!serverPath) {
+    if (serverPath) {
+        outputChannel.debug(`Server path loaded from VS Code configuration: ${serverPath}`);
+    }
+    else {
         serverPath = await resolveLocalCompiler(workspaceFolder);
     }
     if (!serverPath) {
         const executable = process.platform === "win32" ? "tsp-server.cmd" : "tsp-server";
+        outputChannel.debug(`Can't resolve server path, try to use default value ${executable}.`);
         return { command: executable, args, options };
     }
     const variableResolver = new VSCodeVariableResolver({
@@ -21142,6 +21259,7 @@ async function resolveTypeSpecServer(context) {
         workspaceRoot: workspaceFolder, // workspaceRoot is deprecated but we still support it for backwards compatibility.
     });
     serverPath = variableResolver.resolve(serverPath);
+    outputChannel.debug(`Server path expanded to: ${serverPath}`);
     if (!serverPath.endsWith(".js")) {
         // Allow path to tsp-server.cmd to be passed.
         if (await isFile$1(serverPath)) {
@@ -21167,15 +21285,22 @@ async function resolveLocalCompiler(baseDir) {
         stat: promises.stat,
     };
     try {
+        outputChannel.debug(`Try to resolve compiler from local, baseDir: ${baseDir}`);
         const executable = await resolveModule(host, "@typespec/compiler", {
             baseDir,
         });
         if (executable.type === "module") {
+            outputChannel.debug(`Resolved compiler from local: ${executable.path}`);
             return executable.path;
         }
+        else {
+            outputChannel.debug(`Failed to resolve compiler from local. Unexpected executable type: ${executable.type}`);
+        }
     }
     catch (e) {
         // Couldn't find the module
+        outputChannel.debug("Exception when resolving compiler from local", e);
+        return undefined;
     }
     return undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespec-vscode",
-  "version": "0.57.0-dev.2",
+  "version": "0.57.0-dev.3",
   "author": "Microsoft Corporation",
   "description": "TypeSpec language support for VS Code",
   "homepage": "https://typespec.io",
@@ -59,13 +59,24 @@
     ],
     "configuration": [
       {
-        "title": "TypeSpec Language Server Path",
+        "title": "TypeSpec",
         "properties": {
           "typespec.tsp-server.path": {
             "type": "string",
             "default": "",
             "description": "Path to `tsp-server` command that runs the TypeSpec language server.\n\nIf not specified, then `tsp-server` found on PATH is used.\n\nExample (User): /usr/local/bin/tsp-server\nExample (Workspace): ${workspaceFolder}/node_modules/@typespec/compiler",
             "scope": "machine-overridable"
+          },
+          "typespec.trace.server": {
+            "scope": "window",
+            "type": "string",
+            "enum": [
+              "off",
+              "messages",
+              "verbose"
+            ],
+            "default": "off",
+            "description": "Define whether/how the TypeSpec language server should send traces to client. For the traces to show properly in vscode Output, make sure 'Log Level' is also set to 'Trace' so that they won't be filtered at client side, which can be set through 'Developer: Set Log Level...' command."
           }
         }
       }