Support Emitter section in init-template when creating TypeSpec project in vscode (#5594)

Support Emitter section in init-template when creating TypeSpec project
in vscode

fixes: #5426

Author: RodgeFu

.chronus/changes/scaffolding-emitter-2025-0-14-11-30-33.md

@@ -0,0 +1,8 @@
+---
+changeKind: feature
+packages:
+  - "@typespec/compiler"
+  - typespec-vscode
+---
+
+Support Emitters section in Init Template when creating TypeSpec project in vscode

packages/compiler/src/server/types.ts

@@ -39,7 +39,7 @@ import {
 import { TextDocument, TextEdit } from "vscode-languageserver-textdocument";
 import type { CompilerHost, Program, SourceFile, TypeSpecScriptNode } from "../core/index.js";
 import { LoadedCoreTemplates } from "../init/core-templates.js";
-import { InitTemplate, InitTemplateLibrarySpec } from "../init/init-template.js";
+import { EmitterTemplate, InitTemplate, InitTemplateLibrarySpec } from "../init/init-template.js";
 import { ScaffoldingConfig } from "../init/scaffold.js";
 
 export type ServerLogLevel = "trace" | "debug" | "info" | "warning" | "error";
@@ -172,3 +172,4 @@ export interface InitProjectContext {
 export type InitProjectConfig = ScaffoldingConfig;
 export type InitProjectTemplate = InitTemplate;
 export type InitProjectTemplateLibrarySpec = InitTemplateLibrarySpec;
+export type InitProjectTemplateEmitterTemplate = EmitterTemplate;

packages/typespec-vscode/src/extension-state-manager.ts

@@ -0,0 +1,61 @@
+import { LogLevel } from "rollup";
+import vscode from "vscode";
+import { normalizePath } from "./path-utils.js";
+
+export interface StartUpMessage {
+  /**
+   * the message to show in the popup notification
+   */
+  popupMessage: string;
+  /**
+   * the detail logged to the Output window
+   */
+  detail: string;
+  /**
+   * the level used to show notification and log
+   */
+  level: LogLevel;
+}
+
+/** manage data stored in vscode extension's state (ExtensionContext.globalState/workspaceState) */
+export class ExtensionStateManager {
+  constructor(private vscodeContext: vscode.ExtensionContext) {}
+
+  private getValue<T>(key: string, defaultValue: T, isGlobal: boolean): T {
+    return isGlobal
+      ? this.vscodeContext.globalState.get(key, defaultValue)
+      : this.vscodeContext.workspaceState.get(key, defaultValue);
+  }
+
+  /**
+   *
+   * @param key
+   * @param value must be JSON stringifyable, set to undefined to delete the key
+   * @param isGlobal
+   */
+  private setValue<T>(key: string, value: T | undefined, isGlobal: boolean) {
+    isGlobal
+      ? this.vscodeContext.globalState.update(key, value)
+      : this.vscodeContext.workspaceState.update(key, value);
+  }
+
+  private getStartUpMessageKey(workspaceFolder: string) {
+    const ON_START_UP_MESSAGE_KEY_PREFIX = "onStartUpMessage-";
+    const path = normalizePath(workspaceFolder);
+    return `${ON_START_UP_MESSAGE_KEY_PREFIX}${path}`;
+  }
+
+  saveStartUpMessage(msg: StartUpMessage, workspaceFolder: string) {
+    const key = this.getStartUpMessageKey(workspaceFolder);
+    this.setValue(key, msg, true);
+  }
+  loadStartUpMessage(workspaceFolder: string): StartUpMessage | undefined {
+    const key = this.getStartUpMessageKey(workspaceFolder);
+    const value = this.getValue<StartUpMessage | undefined>(key, undefined, true);
+    return value;
+  }
+  cleanUpStartUpMessage(workspaceFolder: string) {
+    const key = this.getStartUpMessageKey(workspaceFolder);
+    this.setValue(key, undefined, true);
+  }
+}

packages/typespec-vscode/src/extension.ts

@@ -1,7 +1,8 @@
 import vscode, { commands, ExtensionContext, TabInputText } from "vscode";
 import { State } from "vscode-languageclient";
 import { createCodeActionProvider } from "./code-action-provider.js";
-import { ExtensionLogListener } from "./log/extension-log-listener.js";
+import { ExtensionStateManager } from "./extension-state-manager.js";
+import { ExtensionLogListener, getPopupAction } from "./log/extension-log-listener.js";
 import logger from "./log/logger.js";
 import { TypeSpecLogOutputChannel } from "./log/typespec-log-output-channel.js";
 import { createTaskProvider } from "./task-provider.js";
@@ -12,6 +13,7 @@ import {
   RestartServerCommandArgs,
   SettingName,
 } from "./types.js";
+import { isWhitespaceStringOrUndefined } from "./utils.js";
 import { createTypeSpecProject } from "./vscode-cmd/create-tsp-project.js";
 import { emitCode } from "./vscode-cmd/emit-code/emit-code.js";
 import { installCompilerGlobally } from "./vscode-cmd/install-tsp-compiler.js";
@@ -25,6 +27,8 @@ const outputChannel = new TypeSpecLogOutputChannel("TypeSpec");
 logger.registerLogListener("extension-log", new ExtensionLogListener(outputChannel));
 
 export async function activate(context: ExtensionContext) {
+  const stateManager = new ExtensionStateManager(context);
+
   context.subscriptions.push(createTaskProvider());
 
   context.subscriptions.push(createCodeActionProvider());
@@ -99,7 +103,7 @@ export async function activate(context: ExtensionContext) {
 
   context.subscriptions.push(
     commands.registerCommand(CommandName.CreateProject, async () => {
-      await createTypeSpecProject(client);
+      await createTypeSpecProject(client, stateManager);
     }),
   );
 
@@ -143,7 +147,7 @@ export async function activate(context: ExtensionContext) {
         return t.input.uri.fsPath.endsWith(".tsp");
       }) >= 0
   ) {
-    return await vscode.window.withProgress(
+    await vscode.window.withProgress(
       {
         title: "Launching TypeSpec language service...",
         location: vscode.ProgressLocation.Notification,
@@ -155,6 +159,7 @@ export async function activate(context: ExtensionContext) {
   } else {
     logger.info("No workspace opened, Skip starting TypeSpec language service.");
   }
+  showStartUpMessages(stateManager);
 }
 
 export async function deactivate() {
@@ -169,3 +174,35 @@ async function recreateLSPClient(context: ExtensionContext) {
   await client.start();
   return client;
 }
+
+function showStartUpMessages(stateManager: ExtensionStateManager) {
+  vscode.workspace.workspaceFolders?.forEach((workspaceFolder) => {
+    const msg = stateManager.loadStartUpMessage(workspaceFolder.uri.fsPath);
+    if (msg) {
+      logger.log("debug", "Start up message found for folder: " + workspaceFolder.uri.fsPath);
+      if (isWhitespaceStringOrUndefined(msg.detail)) {
+        logger.log(msg.level, msg.popupMessage, [], {
+          showPopup: true,
+        });
+      } else {
+        const SHOW_DETAIL = "View Details in Output";
+        const popupAction = getPopupAction(msg.level);
+        if (popupAction) {
+          popupAction(msg.popupMessage, SHOW_DETAIL).then((action) => {
+            if (action === SHOW_DETAIL) {
+              outputChannel.show(true);
+            }
+            // log the start up message to Output no matter user clicked the button or not
+            // and there are many logs coming when starting the extension, so
+            // log the message when the popup is clicked (or disappearing) to make sure these logs are shown at the end of the Output window to catch
+            // user's attention.
+            logger.log(msg.level, msg.popupMessage + "\n", [msg.detail]);
+          });
+        }
+      }
+    } else {
+      logger.log("debug", "No start up message found for folder: " + workspaceFolder.uri.fsPath);
+    }
+    stateManager.cleanUpStartUpMessage(workspaceFolder.uri.fsPath);
+  });
+}

packages/typespec-vscode/src/log/extension-log-listener.ts

@@ -1,49 +1,75 @@
 import vscode from "vscode";
-import { LogItem, LogListener, LogOptions } from "./logger.js";
+import { LogItem, LogLevel, LogListener, LogOptions } from "./logger.js";
 
 export interface ExtensionLogOptions extends LogOptions {
   /** show the Output window in vscode */
-  showOutput: boolean;
+  showOutput?: boolean;
   /** show the log in vscode popup */
-  showPopup: boolean;
+  showPopup?: boolean;
+  /** the text of the button in the popup notification, default is 'View details in Output' */
+  popupButtonText?: string;
+  /** callback when the button in the popup notification is clicked, default is to open the TypeSpec Output */
+  onPopupButtonClicked?: () => void;
+}
+
+export function getPopupAction(loglevel: LogLevel) {
+  switch (loglevel) {
+    case "error":
+      return vscode.window.showErrorMessage;
+    case "warn":
+      return vscode.window.showWarningMessage;
+    case "debug":
+    case "info":
+      return vscode.window.showInformationMessage;
+    default: // trace
+      return undefined;
+  }
 }
 
 export class ExtensionLogListener implements LogListener {
   constructor(private outputChannel?: vscode.LogOutputChannel) {}
 
   Log(log: LogItem) {
     const VIEW_DETAIL_IN_OUTPUT = "View details in Output";
-    const { showOutput, showPopup } = log.options ?? { showOutput: false, showPopup: false };
+    const { showOutput, showPopup, popupButtonText, onPopupButtonClicked } = log.options ?? {
+      showOutput: false,
+      showPopup: false,
+    };
     let popupAction: ((msg: string, ...items: string[]) => Thenable<string>) | undefined;
     switch (log.level) {
       case "error":
         this.outputChannel?.error(log.message, ...(log.details ?? []));
-        popupAction = vscode.window.showErrorMessage;
+        popupAction = getPopupAction(log.level);
         break;
       case "trace":
         this.outputChannel?.trace(log.message, ...(log.details ?? []));
         break;
       case "debug":
         this.outputChannel?.debug(log.message, ...(log.details ?? []));
-        popupAction = vscode.window.showInformationMessage;
+        popupAction = getPopupAction(log.level);
         break;
       case "info":
         this.outputChannel?.info(log.message, ...(log.details ?? []));
-        popupAction = vscode.window.showInformationMessage;
+        popupAction = getPopupAction(log.level);
         break;
       case "warn":
         this.outputChannel?.warn(log.message, ...(log.details ?? []));
-        popupAction = vscode.window.showWarningMessage;
+        popupAction = getPopupAction(log.level);
         break;
     }
     if (showOutput && this.outputChannel) {
       this.outputChannel.show(true /*preserveFocus*/);
     }
 
     if (showPopup && popupAction) {
-      void popupAction(log.message, VIEW_DETAIL_IN_OUTPUT).then((value) => {
-        if (value === VIEW_DETAIL_IN_OUTPUT) {
-          this.outputChannel?.show(true /*preserveFocus*/);
+      const buttonText = popupButtonText ?? VIEW_DETAIL_IN_OUTPUT;
+      void popupAction(log.message, buttonText).then((value) => {
+        if (value === buttonText) {
+          if (onPopupButtonClicked) {
+            onPopupButtonClicked();
+          } else {
+            this.outputChannel?.show(true /*preserveFocus*/);
+          }
         }
       });
     }