vscode#OutputChannel TypeScript Examples

static async startStandardServer(
    context: ExtensionContext,
    clientOptions: LanguageClientOptions,
    serverOptions: ServerOptions,
    outputChannel: OutputChannel,
    telemetry: Telemetry,
  ) {
    if (standardClient.getClientStatus() !== ClientStatus.Uninitialized) {
      return;
    }

    const checkConflicts: boolean = await hasNoBuildToolConflict(context);
    if (!checkConflicts) {
      outputChannel.appendLine(
        `Build tool conflict detected in workspace. Please enable either maven (${IMPORT_MAVEN}) or gradle (${IMPORT_GRADLE}) in user settings.`,
      );
      telemetry.sendEvent('standardJavaServerHasBuildToolConflict');
      return;
    }

    if (javaServerMode === ServerMode.LIGHTWEIGHT) {
      // Before standard server is ready, we are in hybrid.
      javaServerMode = ServerMode.HYBRID;
    }

    await standardClient.initialize(clientOptions, serverOptions);
    standardClient.start();

    outputChannel.appendLine('Java language service (standard) is running.');
    telemetry.sendEvent('standardJavaServerStarted');
  }

function getAppenderModule(channel: OutputChannel): AppenderModule {
  return {
    configure(config: any, layouts: any) {
      const { layoutNormal: n, timezoneOffset } = config;
      const { layout: getLayout, basicLayout } = layouts;
      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
      const normalLayout = getLayout(n.type, n) ?? basicLayout;
      return (event: LoggingEvent) => {
        const msg = normalLayout(event, timezoneOffset);
        channel.appendLine(msg);
      };
    },
  };
}

export function initLog(channel: OutputChannel) {
  return log4js
    .configure({
      appenders: {
        vscChannel: {
          type: getAppenderModule(channel),
          layoutNormal: {
            type: 'basic',
          },
        },
      },
      categories: { default: { appenders: ['vscChannel'], level: 'info' } },
    })
    .getLogger();
}

public static async create(context: ExtensionContext, statusOutput: OutputChannel): Promise<DafnyLanguageClient> {
    const { path: dotnetExecutable } = await getDotnetExecutablePath();
    const launchArguments = [ getLanguageServerRuntimePath(context), ...getLanguageServerLaunchArgs() ];
    statusOutput.appendLine(`Language server arguments: ${DafnyLanguageClient.argumentsToCommandLine(launchArguments)}`);
    const serverOptions: ServerOptions = {
      run: { command: dotnetExecutable, args: launchArguments },
      debug: { command: dotnetExecutable, args: launchArguments }
    };
    const diagnosticsListeners: ((uri: Uri, diagnostics: Diagnostic[]) => void)[] = [];
    const clientOptions: LanguageClientOptions = {
      documentSelector: [ DafnyDocumentFilter ],
      diagnosticCollectionName: LanguageServerId,
      middleware: {
        handleDiagnostics: (uri: Uri, diagnostics: Diagnostic[], next: HandleDiagnosticsSignature) => {
          for(const handler of diagnosticsListeners) {
            handler(uri, diagnostics);
          }
          next(uri, diagnostics);
        }
      }
    };
    return new DafnyLanguageClient(LanguageServerId, LanguageServerName, serverOptions, clientOptions, diagnosticsListeners);
  }

static activateUniversalServer(
    context: ExtensionContext,
    outputChannel: OutputChannel,
    serverOptions: ServerOptions,
    telemetry: Telemetry,
  ) {
    outputChannel.appendLine('Starting universal language server');
    const universalClientOptions: LanguageClientOptions = {
      // Register the server for stripe-supported languages. dotnet is not yet supported.
      documentSelector: [
        {scheme: 'file', language: 'javascript'},
        {scheme: 'file', language: 'typescript'},
        {scheme: 'file', language: 'go'},
        // {scheme: 'file', language: 'java'},
        {scheme: 'file', language: 'php'},
        {scheme: 'file', language: 'python'},
        {scheme: 'file', language: 'ruby'},
      ],
      synchronize: {
        fileEvents: workspace.createFileSystemWatcher('**/.clientrc'),
      },
    };

    const universalClient = new LanguageClient(
      'stripeLanguageServer',
      'Stripe Language Server',
      serverOptions,
      universalClientOptions,
    );

    universalClient.onTelemetry((data: any) => {
      const eventData = data.data || null;
      telemetry.sendEvent(data.name, eventData);
    });

    universalClient.start();
    outputChannel.appendLine('Universal language server is running');
    telemetry.sendEvent('universalLanguageServerStarted');
  }

static async startSyntaxServer(
    clientOptions: LanguageClientOptions,
    serverOptions: ServerOptions,
    outputChannel: OutputChannel,
    telemetry: Telemetry,
  ) {
    await syntaxClient.initialize(clientOptions, serverOptions);
    syntaxClient.start();
    outputChannel.appendLine('Java language service (syntax) is running.');
    telemetry.sendEvent('syntaxJavaServerStarted');
  }

private async executeWithProgress(prompt: string, cmd: string, options: string[], workingDirectory: string | null): Promise<string>{
        let inc = 0;
        let stdout = ''
        /* eslint-disable  @typescript-eslint/no-this-alias */
        const realThis = this;
        await window.withProgress({
            location: ProgressLocation.Notification,
            title: '',
            cancellable: false
        }, (progress) => {
            const progressChannel : OutputChannel = {
                name : 'ProgressChannel',
                append(value: string)
                {
                    stdout += value;
                    if (realThis.outputChannel){
                        // add the output here in case user wants to go look for it.
                        realThis.outputChannel.appendLine(value.trim());
                    }
                    if (inc < 100) {
                        inc += 10;
                    }
                    progress.report({ increment: inc, message: value });
                },
                appendLine(value: string) {
                    this.append(value + '\n');
                },
                replace(value: string) { /* empty */ },
                clear() { /* empty */ },
                show() { /* empty */ },
                hide() { /* empty */ },
                dispose() { /* empty */ }
            }
            progress.report({increment:0, message: prompt});
            return batchExecute(cmd, options, workingDirectory, progressChannel);
        });
        return stdout;
    }

/**
     * Export procedure documentation
     * @param alObject ALObject
     * @param alProcedure ALProcedure
     * @param output OutputChannel
     * @param headingLevel Initial heading level (optional)
     * @returns 
     */
    public static async ExportProcedure(alObject: ALObject, alProcedure: ALProcedure, output: OutputChannel, headingLevel: number = 0) {   
        this.Initialize(output);
        // do not export procedures w/o documentation
        if (alProcedure.ALDocumentation.Exists === ALDocumentationExists.No) {
            this.WriteOutput(`Warning: No documentation found for ${ALProcedureType[alProcedure.Type]} ${alProcedure.Name}()`);
            return;
        }
        let doc = new MarkdownWriter(`${this.GetDocumentationExportPath()}/${alObject.FileName!.replace(/\s/mg, '_').replace('.al', '')}/${alProcedure.Name!.replace(/\s/mg, '_')}.md`);
        await this.WriteProcedureDocumentation(doc, alObject, alProcedure, headingLevel);
    }

export function prepareExecutable(
  jdkInfo: JDKInfo,
  workspacePath: string,
  context: ExtensionContext,
  isSyntaxServer: boolean,
  outputChannel: OutputChannel,
  telemetry: Telemetry,
): Executable {
  try {
    const executable: Executable = Object.create(null);
    const options: ExecutableOptions = Object.create(null);
    options.env = Object.assign({syntaxserver: isSyntaxServer}, process.env);
    executable.options = options;
    executable.command = path.resolve(jdkInfo.javaHome + '/bin/java');
    executable.args = prepareParams(jdkInfo, workspacePath, context, isSyntaxServer, outputChannel, telemetry);
    console.log(`Starting Java server with: ${executable.command} ${executable.args.join(' ')}`);
    return executable;
  } catch (e) {
    const serverType = isSyntaxServer ? 'Syntax' : 'Standard';
    throw new Error(`Failed to start Java ${serverType} server. ${e}`);
  }
}

public static async ExportAsPdf(output: OutputChannel) {
        this.Initialize(output);

        const appJson = this.ReadAppJson();
        let doc = new MarkdownWriter(`${this.GetDocumentationExportPath()}/${appJson.name.replace(/\s/mg, '_')}.md`, this.GetPdfOptions());
        await this.ExportIndex(output, doc);

        let alObjects = ALObjectCache.ALObjects;
        for (const alObject of  alObjects) {
            doc.WriteLine();
            doc.WriteLine('<div class="page-break"></div>');
            doc.WriteLine();
            output.appendLine(`${StringUtil.GetTimestamp()} Exporting documentation for ${ALObjectType[alObject.Type]} ${alObject.Name} . . . `);
            await ALObjectDocumentationExport.ExportObject(alObject, output, true, doc);
        };

        try
        {
            const { mdToPdf } = require ('md-to-pdf');            
            const pdf = await mdToPdf({ path: `${this.GetDocumentationExportPath()}/${appJson.name.replace(/\s/mg, '_')}.md` }).catch(console.error);
            
            if (pdf) {
                fs.writeFileSync(`${this.GetDocumentationExportPath()}/${appJson.name.replace(/\s/mg, '_')}.pdf`, pdf.content);
            } else {
                output.appendLine(`${StringUtil.GetTimestamp()} Error: Unable to create PDF file.`);
            }
        } catch (ex) {
            if (typeof ex === "string") {
                output.appendLine(ex);
            } else if (ex instanceof Error) {
                output.appendLine(ex.message);
            }
        } finally {
            FilesystemHelper.DeleteFile(`${this.GetDocumentationExportPath()}/${appJson.name.replace(/\s/mg, '_')}.md`);
        }        
    }

/**
     * Get or create extension specific output channel
     * @param outputName Name of the Output Channel
     * @returns OutputChannel
     */
    private getOutputChannel(outputName: string): OutputChannel {
        if ((this.output !== undefined) && (this.output !== null)) {
            this.output.clear();
            return this.output;
        }
        this.output = window.createOutputChannel(outputName);
        return this.output;
    }

constructor(outputChannel: OutputChannel, localStorage : LocalStorageService, defaultToolchain : string) {
        this.outputChannel = outputChannel;
        this.defaultToolchain = defaultToolchain;
        this.localStorage = localStorage;
        this.subscriptions.push(commands.registerCommand('lean4.selectToolchain', (args) => this.selectToolchainForActiveEditor(args)));
    }

function getOutputChannel(): OutputChannel {
    if (!_channel) {
        _channel = window.createOutputChannel("SIMPL+ Compile");
    }
    return _channel;
}

private outputChannel: OutputChannel;

private outputChannel: OutputChannel;

private output(): OutputChannel {
    if (!this.outputChannel) {
      this.outputChannel = window.createOutputChannel(this.outputChannelName);
    }
    return this.outputChannel;
  }

private outputChannel?: OutputChannel;

constructor(localStorage : LocalStorageService, installer : LeanInstaller, pkgService : LeanpkgService, outputChannel : OutputChannel) {
        this.localStorage = localStorage;
        this.outputChannel = outputChannel;
        this.installer = installer;
        this.pkgService = pkgService;

        // Only change the document language for *visible* documents,
        // because this closes and then reopens the document.
        window.visibleTextEditors.forEach((e) => this.didOpenEditor(e.document));
        this.subscriptions.push(window.onDidChangeVisibleTextEditors((es) =>
            es.forEach((e) => this.didOpenEditor(e.document))));

        this.subscriptions.push(
            commands.registerCommand('lean4.refreshFileDependencies', () => this.refreshFileDependencies()),
            commands.registerCommand('lean4.restartServer', () => this.restartActiveClient())
        );

        workspace.onDidOpenTextDocument((document) => this.didOpenEditor(document));

        workspace.onDidChangeWorkspaceFolders((event) => {
            for (const folder of event.removed) {
                const key = this.getKeyFromUri(folder.uri);
                const client = this.clients.get(key);
                if (client) {
                    this.clients.delete(key);
                    this.versions.delete(key);
                    client.dispose();
                    this.clientRemovedEmitter.fire(client);
                }
            }
        });

        installer.installChanged(async (uri: Uri) => {
            // This Uri could be 'undefined' in the case of a selectToolChain "reset"
            // Or it could be a package Uri in the case a lean package file was changed
            // or it could be a document Uri in the case of a command from
            // selectToolchainForActiveEditor.
            const key = this.getKeyFromUri(uri);
            const path = uri.toString();
            if (this.testing.has(key)) {
                console.log(`Blocking re-entrancy on ${path}`);
                return;
            }
            // avoid re-entrancy since testLeanVersion can take a while.
            this.testing.set(key, true);
            try {
                // have to check again here in case elan install had --default-toolchain none.
                const [workspaceFolder, folder, packageFileUri] = await findLeanPackageRoot(uri);
                const packageUri = folder ? folder : Uri.from({scheme: 'untitled'});
                const version = await installer.testLeanVersion(packageUri);
                if (version.version === '4') {
                    const [cached, client] = await this.ensureClient(uri, version);
                    if (cached && client) {
                        await client.restart();
                    }
                } else if (version.error) {
                    console.log(`Lean version not ok: ${version.error}`);
                }
            } catch (e) {
                console.log(`Exception checking lean version: ${e}`);
            }
            this.testing.delete(key);
        });
    }

private readonly _outputChannel: OutputChannel;

constructor(workspaceFolder: WorkspaceFolder | undefined, folderUri: Uri, storageManager : LocalStorageService, outputChannel : OutputChannel) {
        this.storageManager = storageManager;
        this.outputChannel = outputChannel;
        this.workspaceFolder = workspaceFolder; // can be null when opening adhoc files.
        this.folderUri = folderUri;
        this.subscriptions.push(workspace.onDidChangeConfiguration((e) => this.configChanged(e)));
    }

_channel: OutputChannel

static async registerSwitchJavaServerModeCommand(
    context: ExtensionContext,
    jdkInfo: JDKInfo,
    clientOptions: LanguageClientOptions,
    workspacePath: string,
    outputChannel: OutputChannel,
    telemetry: Telemetry,
  ) {
    if ((await commands.getCommands()).includes(Commands.SWITCH_SERVER_MODE)) {
      return;
    }

    /**
     * Command to switch the server mode. Currently it only supports switch from lightweight to standard.
     * @param force force to switch server mode without asking
     */
    commands.registerCommand(
      Commands.SWITCH_SERVER_MODE,
      async (switchTo: ServerMode, force: boolean = false) => {
        const isWorkspaceTrusted = (workspace as any).isTrusted;
        if (isWorkspaceTrusted !== undefined && !isWorkspaceTrusted) {
          // keep compatibility for old engines < 1.56.0
          const button = 'Manage Workspace Trust';
          const choice = await window.showInformationMessage(
            'For security concern, Java language server cannot be switched to Standard mode in untrusted workspaces.',
            button,
          );
          if (choice === button) {
            commands.executeCommand('workbench.action.manageTrust');
          }
          return;
        }

        const clientStatus: ClientStatus = standardClient.getClientStatus();
        if (clientStatus === ClientStatus.Starting || clientStatus === ClientStatus.Started) {
          return;
        }

        if (javaServerMode === switchTo || javaServerMode === ServerMode.STANDARD) {
          return;
        }

        let choice: string;
        if (force) {
          choice = 'Yes';
        } else {
          choice =
            (await window.showInformationMessage(
              'Are you sure you want to switch the Java language server to Standard mode?',
              'Yes',
              'No',
            )) || 'No';
        }

        if (choice === 'Yes') {
          telemetry.sendEvent('switchToStandardMode');

          try {
            this.startStandardServer(
              context,
              clientOptions,
              prepareExecutable(jdkInfo, workspacePath, context, false, outputChannel, telemetry),
              outputChannel,
              telemetry,
            );
          } catch (e) {
            outputChannel.appendLine(`${e}`);
            telemetry.sendEvent('failedToSwitchToStandardMode');
          }
        }
      },
    );
  }

export async function getJavaSDKInfo(
  context: ExtensionContext,
  outputChannel: OutputChannel,
): Promise<JDKInfo> {
  let source: string;
  let javaVersion: number = 0;
  // get java.home from vscode settings config first
  let javaHome = workspace.getConfiguration().get<string>(STRIPE_JAVA_HOME) || '';
  let sdkInfo = {javaVersion, javaHome};

  if (javaHome) {
    source = `${STRIPE_JAVA_HOME} variable defined in ${env.appName} settings`;
    javaHome = expandHomeDir(javaHome);
    if (!(await fse.pathExists(javaHome))) {
      outputChannel.appendLine(
        `The ${source} points to a missing or inaccessible folder (${javaHome})`,
      );
    } else if (!(await fse.pathExists(path.resolve(javaHome, 'bin', JAVAC_FILENAME)))) {
      let msg: string;
      if (await fse.pathExists(path.resolve(javaHome, JAVAC_FILENAME))) {
        msg = `'bin' should be removed from the ${source} (${javaHome})`;
      } else {
        msg = `The ${source} (${javaHome}) does not point to a JDK.`;
      }
      outputChannel.appendLine(msg);
    }
    javaVersion = await getJavaVersion(javaHome) || 0;
    sdkInfo = {javaHome, javaVersion};

    if (javaVersion < REQUIRED_JDK_VERSION) {
      await window.showInformationMessage(
        `The JDK version specified in your user settings does not meet the minimum required version ${REQUIRED_JDK_VERSION}. \
        Do you want to check other installed JDK versions?`, ...['Yes', 'No'])
        .then(async (option) => {
          if (option === 'Yes') {
            sdkInfo = await autoDetectInstalledJDKsAndUpdateConfig(context);
          }
        }
      );
    } else {
      // do nothing. stripe.java.home defined and meets requriement
    }
  } else {
    sdkInfo = await autoDetectInstalledJDKsAndUpdateConfig(context);
  }

  return sdkInfo;
}

/**
 * See https://www.eclipse.org/community/eclipse_newsletter/2017/may/article4.php
 * for required paramters to run the Eclipse JDT server
 */
export function prepareParams(
  jdkInfo: JDKInfo,
  workspacePath: string,
  context: ExtensionContext,
  isSyntaxServer: boolean,
  outputChannel: OutputChannel,
  telemetry: Telemetry,
): string[] {
  const params: string[] = [];
  const inDebug = startedInDebugMode();

  if (inDebug) {
    const port = isSyntaxServer ? 1047 : 1046;
    params.push(`-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=${port},quiet=y`);
  }

  if (jdkInfo.javaVersion > 8) {
    params.push(
      '--add-modules=ALL-SYSTEM',
      '--add-opens',
      'java.base/java.util=ALL-UNNAMED',
      '--add-opens',
      'java.base/java.lang=ALL-UNNAMED',
    );
  }

  params.push(
    '-Declipse.application=org.eclipse.jdt.ls.core.id1',
    '-Dosgi.bundles.defaultStartLevel=4',
    '-Declipse.product=org.eclipse.jdt.ls.core.product',
  );

  if (inDebug) {
    params.push('-Dlog.level=ALL');
  }

  const encodingKey = '-Dfile.encoding=';
  params.push(encodingKey + getJavaEncoding());

  const serverHome: string = path.resolve(__dirname, javaServerPath);
  const launchersFound: Array<string> = getServerLauncher(serverHome);

  if (launchersFound && launchersFound.length) {
    params.push('-jar');
    params.push(path.resolve(serverHome, launchersFound[0]));
  } else {
   throw new Error('Server jar not found');
  }

  // select configuration directory according to OS
  let configDir = isSyntaxServer ? 'config_ss_win' : 'config_win';
  if (process.platform === 'darwin') {
    configDir = isSyntaxServer ? 'config_ss_mac' : 'config_mac';
  } else if (process.platform === 'linux') {
    configDir = isSyntaxServer ? 'config_ss_linux' : 'config_linux';
  }

  params.push('-configuration');
  if (startedFromSources()) {
    // dev mode
    params.push(path.resolve(__dirname, javaServerPath, configDir));
  } else {
    const config = resolveConfiguration(context, configDir, outputChannel, telemetry);
    if (config) {
      params.push(config);
    } else {
      throw new Error('Failed to get server configuration file.');
    }
  }

  params.push('-data');
  params.push(workspacePath);

  return params;
}

export function resolveConfiguration(
  context: ExtensionContext,
  configDir: string,
  outputChannel: OutputChannel,
  telemetry: Telemetry
): string {
  ensureExists(context.globalStoragePath);
  let version = '0.0.0';
  try {
    const extensionPath = path.resolve(context.extensionPath, 'package.json');
    const packageFile = JSON.parse(fs.readFileSync(extensionPath, 'utf8'));
    if (packageFile) {
      version = packageFile.version;
    }
  } catch {
    outputChannel.appendLine('Cannot locate package.json to parse for extension version. Default to 0.0.0');
    telemetry.sendEvent('cannotParseForExtensionVersion');
  }

  let configuration = path.resolve(context.globalStoragePath, version);
  ensureExists(configuration);
  configuration = path.resolve(configuration, configDir);
  ensureExists(configuration);

  const configIniName = 'config.ini';
  const configIni = path.resolve(configuration, configIniName);
  const ini = path.resolve(__dirname, javaServerPath, configDir, configIniName);
  if (!checkPathExists(configIni)) {
    fs.copyFileSync(ini, configIni);
  } else {
    const configIniTime = getTimestamp(configIni);
    const iniTime = getTimestamp(ini);
    if (iniTime > configIniTime) {
      deleteDirectory(configuration);
      resolveConfiguration(context, configDir, outputChannel, telemetry);
    }
  }

  return configuration;
}

private _channel: OutputChannel;

public constructor(
    private readonly context: ExtensionContext,
    private readonly statusOutput: OutputChannel
  ) {
    this.installer = new DafnyInstaller(context, statusOutput);
  }

private output!: OutputChannel;

/**
     * Initialize ALObjectDocumentationExport
     * @param output OutputChannel
     */
    private static Initialize(output: OutputChannel) {
        this.output = output;
    }