thisismissem.social
forked from
slices.network/slices
Highly ambitious ATProtocol AppView service and sdks
lexicon-itellisense: Improve language server
This change:
- Improves finding & filtering of lexicon files
- Adds a logger for better debugging
- Unsubscribes from the workspace events when enableValidation is false
- Removes duplication between extension.ts and language-server.ts
+367
-154
+53
-65
packages/lexicon-intellisense/src/extension.ts
+53
-65
packages/lexicon-intellisense/src/extension.ts
···
1
-
import * as vscode from 'vscode';
2
-
import * as path from 'path';
3
-
import { LexiconLanguageServer } from './language-server';
1
+
import * as vscode from "vscode";
2
+
import * as path from "path";
3
+
import { LexiconLanguageServer } from "./language-server";
4
4
5
5
let languageServer: LexiconLanguageServer | undefined;
6
6
···
12
12
languageServer.start();
13
13
14
14
// Register commands
15
-
const validateCommand = vscode.commands.registerCommand('lexiconIntelliSense.validateFile', async () => {
16
-
const activeEditor = vscode.window.activeTextEditor;
17
-
if (!activeEditor) {
18
-
vscode.window.showErrorMessage('No active editor found');
19
-
return;
20
-
}
15
+
const validateCommand = vscode.commands.registerCommand(
16
+
"lexiconIntelliSense.validateFile",
17
+
async () => {
18
+
const activeEditor = vscode.window.activeTextEditor;
19
+
if (!activeEditor) {
20
+
vscode.window.showErrorMessage("No active editor found");
21
+
return;
22
+
}
21
23
22
-
const document = activeEditor.document;
23
-
if (!isLexiconFile(document)) {
24
-
vscode.window.showErrorMessage('Current file is not a lexicon JSON file');
25
-
return;
26
-
}
24
+
const document = activeEditor.document;
25
+
if (!languageServer?.isLexiconDocument(document)) {
26
+
vscode.window.showErrorMessage(
27
+
"Current file is not a lexicon JSON file",
28
+
);
29
+
return;
30
+
}
27
31
28
-
try {
29
-
await languageServer?.validateDocument(document);
30
-
vscode.window.showInformationMessage('Lexicon validation completed');
31
-
} catch (error) {
32
-
vscode.window.showErrorMessage(`Validation failed: ${error instanceof Error ? error.message : String(error)}`);
33
-
}
34
-
});
32
+
try {
33
+
await languageServer?.validateDocument(document);
34
+
vscode.window.showInformationMessage("Lexicon validation completed");
35
+
} catch (error) {
36
+
vscode.window.showErrorMessage(
37
+
`Validation failed: ${error instanceof Error ? error.message : String(error)}`,
38
+
);
39
+
}
40
+
},
41
+
);
35
42
36
-
const validateWorkspaceCommand = vscode.commands.registerCommand('lexiconIntelliSense.validateWorkspace', async () => {
37
-
if (!languageServer) {
38
-
vscode.window.showErrorMessage('Language server not initialized');
39
-
return;
40
-
}
41
-
42
-
try {
43
-
const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
44
-
if (!workspaceFolder) {
45
-
vscode.window.showErrorMessage('No workspace folder found');
43
+
const validateWorkspaceCommand = vscode.commands.registerCommand(
44
+
"lexiconIntelliSense.validateWorkspace",
45
+
async () => {
46
+
if (!languageServer) {
47
+
vscode.window.showErrorMessage("Language server not initialized");
46
48
return;
47
49
}
48
50
49
-
await languageServer.validateWorkspace(workspaceFolder.uri);
50
-
vscode.window.showInformationMessage('Workspace lexicon validation completed');
51
-
} catch (error) {
52
-
vscode.window.showErrorMessage(`Workspace validation failed: ${error instanceof Error ? error.message : String(error)}`);
53
-
}
54
-
});
51
+
try {
52
+
if (
53
+
!vscode.workspace.workspaceFolders ||
54
+
vscode.workspace.workspaceFolders.length <= 0
55
+
) {
56
+
vscode.window.showErrorMessage("No workspace folders found");
57
+
return;
58
+
}
55
59
56
-
context.subscriptions.push(validateCommand, validateWorkspaceCommand);
60
+
await languageServer.validateWorkspaceFolders();
57
61
58
-
// Watch for configuration changes
59
-
const configWatcher = vscode.workspace.onDidChangeConfiguration((event) => {
60
-
if (event.affectsConfiguration('lexiconIntelliSense')) {
61
-
languageServer?.updateConfiguration();
62
-
}
63
-
});
62
+
vscode.window.showInformationMessage(
63
+
"Workspace lexicon validation completed",
64
+
);
65
+
} catch (error) {
66
+
vscode.window.showErrorMessage(
67
+
`Workspace validation failed: ${error instanceof Error ? error.message : String(error)}`,
68
+
);
69
+
}
70
+
},
71
+
);
64
72
65
-
context.subscriptions.push(configWatcher);
73
+
context.subscriptions.push(validateCommand, validateWorkspaceCommand);
66
74
}
67
75
68
76
export function deactivate() {
···
71
79
languageServer = undefined;
72
80
}
73
81
}
74
-
75
-
function isLexiconFile(document: vscode.TextDocument): boolean {
76
-
// Check if file is in lexicons directory or has lexicon-like content
77
-
const filePath = document.uri.fsPath;
78
-
const isInLexiconsDir = filePath.includes('/lexicons/') || filePath.includes('\\lexicons\\');
79
-
80
-
if (isInLexiconsDir && document.languageId === 'json') {
81
-
return true;
82
-
}
83
-
84
-
// Check if JSON content looks like a lexicon
85
-
try {
86
-
const content = JSON.parse(document.getText());
87
-
return content && typeof content === 'object' &&
88
-
typeof content.id === 'string' &&
89
-
content.defs;
90
-
} catch {
91
-
return false;
92
-
}
93
-
}
+234
-89
packages/lexicon-intellisense/src/language-server.ts
+234
-89
packages/lexicon-intellisense/src/language-server.ts
···
1
1
import * as vscode from "vscode";
2
2
import * as path from "path";
3
-
import * as fs from "fs";
4
-
import {
5
-
LanguageClient,
6
-
LanguageClientOptions,
7
-
ServerOptions,
8
-
TransportKind,
9
-
} from "vscode-languageclient/node";
10
-
import {
11
-
LexiconValidator,
12
-
ValidationError,
13
-
validate,
14
-
validateWithDetails,
15
-
type LexiconDoc,
16
-
} from "./lexicon";
3
+
import * as fs from "fs/promises";
4
+
import { LanguageClient } from "vscode-languageclient/node";
5
+
import { validate, type LexiconDoc } from "./lexicon";
6
+
import Logger from "./logger";
7
+
8
+
type LexiconLanguageServerConfiguration = {
9
+
enableValidation: boolean;
10
+
lexiconDirectory: string;
11
+
};
12
+
13
+
async function pathExists(path: string): Promise<boolean> {
14
+
return await fs
15
+
.access(path, fs.constants.F_OK)
16
+
.then(() => true)
17
+
.catch(() => false);
18
+
}
19
+
20
+
function normalizePath(inputPath: string) {
21
+
return inputPath.replace("\\", path.sep).replace("/", path.sep);
22
+
}
17
23
18
24
export class LexiconLanguageServer {
19
25
private client: LanguageClient | undefined;
20
26
private context: vscode.ExtensionContext;
21
27
private diagnosticCollection: vscode.DiagnosticCollection;
28
+
private configuration: LexiconLanguageServerConfiguration;
29
+
private logger: Logger;
30
+
private workspaceSubscription?: vscode.Disposable;
22
31
23
32
constructor(context: vscode.ExtensionContext) {
24
33
this.context = context;
34
+
this.logger = new Logger("lexicon");
25
35
this.diagnosticCollection =
26
36
vscode.languages.createDiagnosticCollection("lexicon");
27
37
context.subscriptions.push(this.diagnosticCollection);
38
+
39
+
// Special disposable for disposing of workspace subscriptions if they exist:
40
+
context.subscriptions.push({
41
+
dispose: () => {
42
+
if (this.workspaceSubscription) {
43
+
this.workspaceSubscription.dispose();
44
+
this.workspaceSubscription = undefined;
45
+
}
46
+
},
47
+
});
48
+
49
+
this.configuration = this.loadConfiguration();
28
50
}
29
51
30
52
async start() {
31
-
// Set up document change listeners for real-time validation
32
-
const documentSelector = [
33
-
{ scheme: "file", language: "json", pattern: "**/lexicons/**/*.json" },
34
-
];
53
+
// Setup watcher for the configuration changing:
54
+
const configWatcher = vscode.workspace.onDidChangeConfiguration(
55
+
async (event) => {
56
+
if (event.affectsConfiguration("lexiconIntelliSense")) {
57
+
this.logger.debug("Reloading configuration");
58
+
this.loadConfiguration();
35
59
60
+
if (!this.configuration.enableValidation) {
61
+
this.logger.info(
62
+
"Lexicon validation disabled in config, set lexiconIntelliSense.enableValidation to true to enable",
63
+
);
64
+
65
+
if (this.workspaceSubscription) {
66
+
this.workspaceSubscription.dispose();
67
+
this.workspaceSubscription = undefined;
68
+
}
69
+
70
+
return;
71
+
} else if (!this.workspaceSubscription) {
72
+
this.workspaceSubscription = this.subscribeToWorkspaceEvents();
73
+
}
74
+
75
+
// Revalidate all documents based on new configuration:
76
+
await this.validateAllOpenDocuments();
77
+
78
+
// Revalidate the entire workspace:
79
+
await this.validateWorkspaceFolders();
80
+
}
81
+
},
82
+
);
83
+
84
+
this.context.subscriptions.push(configWatcher);
85
+
86
+
if (!this.configuration.enableValidation) {
87
+
this.logger.info(
88
+
"Lexicon validation disabled in config, set lexiconIntelliSense.enableValidation to true to enable",
89
+
);
90
+
91
+
return;
92
+
}
93
+
94
+
this.workspaceSubscription = this.subscribeToWorkspaceEvents();
95
+
96
+
// Validate all open documents:
97
+
await this.validateAllOpenDocuments();
98
+
99
+
// Validate all lexicon documents in the workspace
100
+
await this.validateWorkspaceFolders();
101
+
}
102
+
103
+
stop() {
104
+
if (this.client) {
105
+
this.client.stop();
106
+
this.client = undefined;
107
+
}
108
+
}
109
+
110
+
subscribeToWorkspaceEvents(): vscode.Disposable {
111
+
this.logger.debug("Subscribing to workspace events");
36
112
// Listen for document changes
37
113
const changeListener = vscode.workspace.onDidChangeTextDocument(
38
114
async (event) => {
39
-
if (this.isLexiconDocument(event.document)) {
115
+
if (this.canValidateDocument(event.document)) {
40
116
await this.validateDocument(event.document);
41
117
}
42
-
}
118
+
},
43
119
);
44
120
45
121
// Listen for document saves
46
122
const saveListener = vscode.workspace.onDidSaveTextDocument(
47
123
async (document) => {
48
-
if (this.isLexiconDocument(document)) {
124
+
if (this.canValidateDocument(document)) {
49
125
await this.validateDocument(document);
126
+
50
127
// Re-run workspace validation to check cross-references
51
-
if (vscode.workspace.workspaceFolders) {
52
-
for (const workspaceFolder of vscode.workspace.workspaceFolders) {
53
-
await this.validateWorkspace(workspaceFolder.uri);
54
-
}
55
-
}
128
+
await this.validateWorkspaceFolders();
56
129
}
57
-
}
130
+
},
58
131
);
59
132
60
-
this.context.subscriptions.push(changeListener, saveListener);
133
+
return vscode.Disposable.from(saveListener, changeListener, {
134
+
dispose: () => {
135
+
this.logger.debug("Unsubscribing from workspace events");
136
+
},
137
+
});
138
+
}
61
139
62
-
// Validate all lexicon documents in the workspace
63
-
if (vscode.workspace.workspaceFolders) {
64
-
for (const workspaceFolder of vscode.workspace.workspaceFolders) {
65
-
await this.validateWorkspace(workspaceFolder.uri);
66
-
}
140
+
loadConfiguration() {
141
+
const config = vscode.workspace.getConfiguration("lexiconIntelliSense");
142
+
const enableValidation = !!config.get<boolean>("enableValidation", true);
143
+
let lexiconDirectory = config.get<string>("lexiconDirectory", "/lexicons");
144
+
145
+
if (typeof lexiconDirectory !== "string" || lexiconDirectory.length === 0) {
146
+
this.logger.warn(
147
+
"Configuration value lexiconDirectory was not a string or was empty, using default: lexicons",
148
+
);
149
+
lexiconDirectory = "/lexicons";
67
150
}
68
-
}
69
151
70
-
stop() {
71
-
if (this.client) {
72
-
this.client.stop();
73
-
this.client = undefined;
74
-
}
152
+
// Normalise to path configuration to match system path separator:
153
+
lexiconDirectory = normalizePath(lexiconDirectory);
154
+
155
+
this.configuration = {
156
+
enableValidation,
157
+
lexiconDirectory,
158
+
};
159
+
160
+
return this.configuration;
75
161
}
76
162
77
-
updateConfiguration() {
78
-
// Revalidate all open documents when configuration changes
163
+
async validateAllOpenDocuments() {
164
+
this.logger.debug("Validating all open documents");
165
+
// Revalidate all open documents:
79
166
for (const document of vscode.workspace.textDocuments) {
80
-
if (this.isLexiconDocument(document)) {
167
+
if (this.canValidateDocument(document)) {
81
168
this.validateDocument(document);
82
169
}
83
170
}
84
171
}
85
172
86
-
async validateDocument(document: vscode.TextDocument) {
87
-
const config = vscode.workspace.getConfiguration("lexiconIntelliSense");
88
-
if (!config.get<boolean>("enableValidation", true)) {
89
-
console.log("Validation disabled in config");
90
-
return;
173
+
private canValidateDocument(document: vscode.TextDocument) {
174
+
// Allow validation of new files that are JSON:
175
+
if (document.isUntitled) {
176
+
return document.isDirty && document.languageId === "json";
177
+
} else {
178
+
// Allow validation of saved files:
179
+
return this.isLexiconDocument(document);
91
180
}
181
+
}
92
182
183
+
async validateDocument(document: vscode.TextDocument) {
93
184
const diagnostics: vscode.Diagnostic[] = [];
94
185
95
186
try {
···
102
193
this.createDiagnostic(
103
194
new vscode.Range(0, 0, 0, 0),
104
195
"Lexicon must be an object",
105
-
vscode.DiagnosticSeverity.Error
106
-
)
196
+
vscode.DiagnosticSeverity.Error,
197
+
),
107
198
);
108
199
} else {
109
200
// Validate required fields
···
112
203
this.createDiagnostic(
113
204
new vscode.Range(0, 0, 0, 0),
114
205
'Lexicon must have a valid "id" field',
115
-
vscode.DiagnosticSeverity.Error
116
-
)
206
+
vscode.DiagnosticSeverity.Error,
207
+
),
117
208
);
118
209
}
119
210
···
122
213
this.createDiagnostic(
123
214
new vscode.Range(0, 0, 0, 0),
124
215
'Lexicon must have a "defs" object',
125
-
vscode.DiagnosticSeverity.Error
126
-
)
216
+
vscode.DiagnosticSeverity.Error,
217
+
),
127
218
);
128
219
}
129
220
}
···
136
227
? parseError.message
137
228
: String(parseError)
138
229
}`,
139
-
vscode.DiagnosticSeverity.Error
140
-
)
230
+
vscode.DiagnosticSeverity.Error,
231
+
),
141
232
);
142
233
}
143
234
144
-
console.log("Setting diagnostics:", diagnostics.length, "errors found");
235
+
this.logger.debug(
236
+
`Setting diagnostics: ${diagnostics.length} errors found`,
237
+
);
145
238
this.diagnosticCollection.set(document.uri, diagnostics);
239
+
}
240
+
241
+
async validateWorkspaceFolders() {
242
+
if (vscode.workspace.workspaceFolders) {
243
+
for (const workspaceFolder of vscode.workspace.workspaceFolders) {
244
+
await this.validateWorkspace(workspaceFolder.uri);
245
+
}
246
+
}
146
247
}
147
248
148
249
async validateWorkspace(workspaceUri: vscode.Uri) {
149
-
const config = vscode.workspace.getConfiguration("lexiconIntelliSense");
150
-
const lexiconDir = config.get<string>("lexiconDirectory", "lexicons");
250
+
const lexiconPath = path.resolve(
251
+
workspaceUri.fsPath,
252
+
this.configuration.lexiconDirectory,
253
+
);
151
254
152
-
const lexiconPath = path.join(workspaceUri.fsPath, lexiconDir);
153
-
if (!fs.existsSync(lexiconPath)) {
255
+
if (!(await pathExists(lexiconPath))) {
154
256
// Silently return if lexicons directory doesn't exist - not all projects use lexicons
155
257
return;
156
258
}
···
164
266
const document = await vscode.workspace.openTextDocument(uri);
165
267
await this.validateDocument(document);
166
268
} catch (error) {
167
-
console.warn(`Failed to validate lexicon ${filePath}:`, error);
269
+
this.logger.error(`Failed to validate lexicon ${filePath}:`, error);
168
270
}
169
271
}
170
272
···
174
276
175
277
for (const filePath of lexiconFiles) {
176
278
try {
177
-
const content = fs.readFileSync(filePath, "utf8");
279
+
const content = await fs.readFile(filePath, "utf8");
178
280
const lexicon = JSON.parse(content);
179
-
console.log(lexicon.id, "loaded from", filePath);
281
+
this.logger.debug(`${lexicon.id} loaded from ${filePath}`);
180
282
if (lexicon.id && lexicon.defs) {
181
283
lexicons.push(lexicon);
182
284
idToFileMap.set(lexicon.id, filePath);
183
285
}
184
286
} catch (error) {
185
-
debugger;
186
-
console.warn(`Failed to load lexicon ${filePath}:`, error);
287
+
this.logger.error(`Failed to load lexicon ${filePath}`, error);
187
288
}
188
289
}
189
290
···
209
310
this.createDiagnostic(
210
311
new vscode.Range(0, 0, 0, 0),
211
312
error,
212
-
vscode.DiagnosticSeverity.Error
213
-
)
313
+
vscode.DiagnosticSeverity.Error,
314
+
),
214
315
);
215
316
}
216
317
···
222
323
const totalErrors = errorsByLexiconId
223
324
? Object.values(errorsByLexiconId).reduce(
224
325
(sum: number, errors) => sum + (errors as string[]).length,
225
-
0
326
+
0,
226
327
)
227
328
: 0;
329
+
228
330
if (totalErrors === 0) {
229
-
console.log(
230
-
`Successfully validated ${lexicons.length} lexicon files`
331
+
this.logger.info(
332
+
`Successfully validated ${lexicons.length} lexicon files`,
231
333
);
232
334
} else {
233
-
const errorCount = errorsByLexiconId ? Object.keys(errorsByLexiconId).length : 0;
234
-
console.log(
235
-
`Validation found ${totalErrors} errors across ${errorCount} lexicons`
335
+
const errorCount = errorsByLexiconId
336
+
? Object.keys(errorsByLexiconId).length
337
+
: 0;
338
+
339
+
this.logger.info(
340
+
`Validation found ${totalErrors} errors across ${errorCount} lexicons`,
236
341
);
237
342
}
238
343
} catch (error) {
239
-
console.warn(
240
-
`WASM validation failed: ${
241
-
error instanceof Error ? error.message : String(error)
242
-
}`
243
-
);
344
+
this.logger.error(`WASM validation failed`, error);
244
345
}
245
346
}
246
347
}
···
248
349
private async findLexiconFiles(directory: string): Promise<string[]> {
249
350
const files: string[] = [];
250
351
251
-
const readDir = async (dir: string) => {
252
-
const entries = fs.readdirSync(dir, { withFileTypes: true });
352
+
this.logger.debug("finding lexicon files: " + directory);
353
+
354
+
const readDir = async (dir: string, isRoot: boolean) => {
355
+
const entries = await fs.readdir(dir, { withFileTypes: true });
253
356
for (const entry of entries) {
254
357
const fullPath = path.join(dir, entry.name);
358
+
359
+
// If we can't read the path, skip it:
360
+
const isReadable = await pathExists(fullPath);
361
+
if (!isReadable) {
362
+
continue;
363
+
}
364
+
255
365
if (entry.isDirectory()) {
256
-
await readDir(fullPath);
257
-
} else if (entry.name.endsWith(".json")) {
258
-
files.push(fullPath);
366
+
// ignore .vscode directory in the root, these are almost certainly
367
+
// configuration files:
368
+
if (entry.name === ".vscode" && isRoot) {
369
+
continue;
370
+
}
371
+
372
+
// Don't recurse into the node_modules directory:
373
+
if (entry.name === "node_modules") {
374
+
continue;
375
+
}
376
+
377
+
await readDir(fullPath, false);
378
+
} else if (entry.isFile()) {
379
+
if (entry.name.endsWith(".json")) {
380
+
files.push(fullPath);
381
+
}
259
382
}
260
383
}
261
384
};
262
385
263
-
await readDir(directory);
386
+
await readDir(directory, true);
387
+
264
388
return files;
265
389
}
266
390
267
-
private isLexiconDocument(document: vscode.TextDocument): boolean {
391
+
isLexiconFilePath(filePath: string): boolean {
392
+
const normalized = normalizePath(filePath);
393
+
if (!filePath.endsWith(".json")) {
394
+
return false;
395
+
}
396
+
397
+
if (
398
+
this.configuration.lexiconDirectory !== "./" &&
399
+
this.configuration.lexiconDirectory !== "/"
400
+
) {
401
+
// normalized is an absolute file path, so we're doing string inclusion,
402
+
// rather than startsWith:
403
+
return normalized.includes(this.configuration.lexiconDirectory);
404
+
}
405
+
406
+
return true;
407
+
}
408
+
409
+
isLexiconDocument(document: vscode.TextDocument): boolean {
268
410
const filePath = document.uri.fsPath;
269
-
const isInLexiconsDir =
270
-
filePath.includes("/lexicons/") || filePath.includes("\\lexicons\\");
411
+
if (document.languageId !== "json") {
412
+
return false;
413
+
}
271
414
272
-
if (isInLexiconsDir && document.languageId === "json") {
415
+
if (this.isLexiconFilePath(filePath)) {
273
416
return true;
274
417
}
275
418
···
279
422
return (
280
423
content &&
281
424
typeof content === "object" &&
425
+
typeof content.lexicon === "number" &&
426
+
content.lexicon === 1 &&
282
427
typeof content.id === "string" &&
283
428
content.defs
284
429
);
···
290
435
private createDiagnostic(
291
436
range: vscode.Range,
292
437
message: string,
293
-
severity: vscode.DiagnosticSeverity
438
+
severity: vscode.DiagnosticSeverity,
294
439
): vscode.Diagnostic {
295
440
const diagnostic = new vscode.Diagnostic(range, message, severity);
296
441
diagnostic.source = "lexicon-intellisense";
+80
packages/lexicon-intellisense/src/logger.ts
+80
packages/lexicon-intellisense/src/logger.ts
···
1
+
// Based on MIT/Apache licensed file from:
2
+
// https://github.com/biomejs/biome-vscode/blob/main/src/logger.ts
3
+
import { type LogOutputChannel, window } from "vscode";
4
+
5
+
export default class Logger {
6
+
/**
7
+
* The output channel for logging messages.
8
+
*/
9
+
private outputChannel: LogOutputChannel;
10
+
11
+
/**
12
+
* Creates a new logger for the given Biome instance
13
+
*/
14
+
constructor(private readonly name: string) {
15
+
this.outputChannel = window.createOutputChannel(name, {
16
+
log: true,
17
+
});
18
+
}
19
+
20
+
public show(preserveFocus: boolean = false): void {
21
+
this.outputChannel.show(preserveFocus);
22
+
}
23
+
24
+
/**
25
+
* Logs a message to the output channel.
26
+
*
27
+
* @param message The message to log.
28
+
*/
29
+
public info(message: string): void {
30
+
this.outputChannel?.info(` ${message}`);
31
+
}
32
+
33
+
/**
34
+
* Logs an error message to the output channel.
35
+
*
36
+
* @param message The error message to log.
37
+
*/
38
+
public error(message?: string, error?: unknown): void {
39
+
if (error !== undefined) {
40
+
const errorMessage =
41
+
error instanceof Error ? error.message : String(error);
42
+
43
+
if (errorMessage) {
44
+
this.outputChannel.error(` ${message ?? ""}:\n${errorMessage}`);
45
+
return;
46
+
}
47
+
}
48
+
49
+
if (message) {
50
+
this.outputChannel.error(` ${message}`);
51
+
}
52
+
}
53
+
54
+
/**
55
+
* Logs a warning message to the output channel.
56
+
*
57
+
* @param message The warning message to log.
58
+
*/
59
+
public warn(message?: string): void {
60
+
this.outputChannel.warn(message ?? "");
61
+
}
62
+
63
+
/**
64
+
* Logs a debug message to the output channel.
65
+
*
66
+
* @param message The debug message to log.
67
+
*/
68
+
public debug(message?: string): void {
69
+
this.outputChannel.debug(message ?? "");
70
+
}
71
+
72
+
/**
73
+
* Logs a verbose message to the output channel.
74
+
*
75
+
* @param message The verbose message to log.
76
+
*/
77
+
public trace(message?: string): void {
78
+
this.outputChannel.trace(message ?? "");
79
+
}
80
+
}