FilesExpand file tree

main

/

ShowHelp.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

147 lines (122 loc) · 4.84 KB

main

/

ShowHelp.ts

Copy path

Top

File metadata and controls

• Code
• Blame

147 lines (122 loc) · 4.84 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

// Copyright (c) Microsoft Corporation.

// Licensed under the MIT License.

import vscode = require("vscode");

import { RequestType } from "vscode-languageclient";

import type { LanguageClient } from "vscode-languageclient/node";

import { LanguageClientConsumer } from "../languageClientConsumer";

export interface IShowHelpArguments {

text: string;

}

export interface IShowHelpResult {

helpText: string;

}

export const ShowHelpRequestType = new RequestType<

IShowHelpArguments,

IShowHelpResult,

void

>("powerShell/showHelp");

// Serves Get-Help output as read-only virtual documents (scheme "powershell-help"),

// so help opens in an editor pane that is searchable and copyable but never marked

// dirty (no save/discard prompt). The command name is carried in the URI path.

class ShowHelpContentProvider implements vscode.TextDocumentContentProvider {

private readonly onDidChangeEmitter = new vscode.EventEmitter<vscode.Uri>();

public readonly onDidChange = this.onDidChangeEmitter.event;

public refresh(uri: vscode.Uri): void {

this.onDidChangeEmitter.fire(uri);

}

public async provideTextDocumentContent(uri: vscode.Uri): Promise<string> {

const commandName = uri.path;

const client = await LanguageClientConsumer.getLanguageClient();

const result = await client.sendRequest(ShowHelpRequestType, {

text: commandName,

});

return result.helpText || `No help found for '${commandName}'.`;

}

public dispose(): void {

this.onDidChangeEmitter.dispose();

}

}

export class ShowHelpFeature extends LanguageClientConsumer {

public static readonly scheme = "powershell-help";

private command: vscode.Disposable;

private contentProvider: ShowHelpContentProvider;

private providerRegistration: vscode.Disposable;

constructor() {

super();

this.contentProvider = new ShowHelpContentProvider();

this.providerRegistration =

vscode.workspace.registerTextDocumentContentProvider(

ShowHelpFeature.scheme,

this.contentProvider,

);

this.command = vscode.commands.registerCommand(

"PowerShell.ShowHelp",

async (item?) => {

const text = ShowHelpFeature.resolveCommandName(item);

if (text === undefined) {

return;

}

await this.showHelp(text);

},

);

}

// Determines the command to show help for: an explicit item, the current

// selection, or the word under the cursor. Returns undefined (and surfaces a

// hint) when there's nothing to look up, rather than falling back to the

// entire document.

private static resolveCommandName(item?: {

Name?: string;

}): string | undefined {

if (item?.Name) {

return item.Name;

}

const editor = vscode.window.activeTextEditor;

if (editor === undefined) {

return undefined;

}

const document = editor.document;

const selection = editor.selection;

if (!selection.isEmpty) {

return document.getText(selection);

}

const wordRange = document.getWordRangeAtPosition(selection.active);

if (wordRange === undefined) {

void vscode.window.showInformationMessage(

"Place the cursor on a PowerShell command to show its help.",

);

return undefined;

}

return document.getText(wordRange);

}

private async showHelp(commandName: string): Promise<void> {

const uri = vscode.Uri.from({

scheme: ShowHelpFeature.scheme,

path: commandName,

});

// Re-fetch in case the help changed since this document was last opened.

this.contentProvider.refresh(uri);

// If this command's help is already open, reuse that editor's column so

// repeated clicks focus the existing pane instead of stacking duplicates.

const existingColumn = vscode.window.tabGroups.all

.flatMap((group) => group.tabs)

.find(

(tab) =>

tab.input instanceof vscode.TabInputText &&

tab.input.uri.toString() === uri.toString(),

)?.group.viewColumn;

const document = await vscode.workspace.openTextDocument(uri);

await vscode.window.showTextDocument(document, {

preview: true,

viewColumn: existingColumn ?? vscode.ViewColumn.Beside,

});

}

public override onLanguageClientSet(

_languageClient: LanguageClient,

// eslint-disable-next-line @typescript-eslint/no-empty-function

): void {}

public dispose(): void {

this.command.dispose();

this.providerRegistration.dispose();

this.contentProvider.dispose();

}

}