refactored webviews, register and notification listeners

Author: Achal1607

vscode/src/commands/webViews.ts

@@ -13,7 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */
-import { JdkDownloaderView } from "../jdkDownloader/view";
+import { JdkDownloaderView } from "../webviews/jdkDownloader/view";
 import { extCommands } from "./commands";
 import { ICommand } from "./types";
 

vscode/src/configurations/handlers.ts

@@ -27,6 +27,10 @@ export const getConfigurationValue = <T>(key: string, defaultValue: T | undefine
     return defaultValue != undefined ? conf.get(key, defaultValue) : conf.get(key) as T;
 }
 
+export const updateConfigurationValue = <T>(key: string, newValue: T): void => {
+    workspace.getConfiguration(extConstants.COMMAND_PREFIX).update(key, newValue);
+}
+
 export const getBuiltinConfigurationValue = <T>(key: string, defaultValue: T | undefined = undefined): T => {
     const splitKey = key.split('.');
     const selector = splitKey?.[0];

vscode/src/configurations/listener.ts

@@ -0,0 +1,59 @@
+/*
+  Copyright (c) 2023-2024, Oracle and/or its affiliates.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+import { ConfigurationChangeEvent, Disposable, TextEditor, window, workspace } from "vscode";
+import { userConfigsListened } from "./configurations/configuration";
+import { globalVars } from "./extension";
+import { asRanges } from "./lsp/protocol";
+
+const configChangeHandler = (params: ConfigurationChangeEvent) => {
+    userConfigsListened.forEach((config: string) => {
+        const doesAffect = params.affectsConfiguration(config);
+        if (doesAffect) {
+            globalVars.clientPromise.restartExtension(globalVars.nbProcessManager, true);
+        }
+    });
+}
+
+const visibleTextEditorsChangeHandler = (editors: readonly TextEditor[]) => {
+    editors.forEach((editor: any) => {
+        let decorationParams = globalVars.decorationParamsByUri.get(editor.document.uri);
+        if (decorationParams) {
+            let decorationType = globalVars.decorations.get(decorationParams.key);
+            if (decorationType) {
+                editor.setDecorations(decorationType, asRanges(decorationParams.ranges));
+            }
+        }
+    });
+}
+
+const configChangeListener = workspace.onDidChangeConfiguration(configChangeHandler);
+const visibleTextEditorsChangeListener = window.onDidChangeVisibleTextEditors(visibleTextEditorsChangeHandler);
+
+const beforeInitlisteners: Disposable[] = [configChangeListener];
+const afterInitlisteners: Disposable[] = [visibleTextEditorsChangeListener];
+
+
+export const registerListenersBeforeClientInit = () => {
+    beforeInitlisteners.forEach(listener => {
+        globalVars.extensionInfo.pushSubscription(listener);
+    });
+}
+
+export const registerListenersAfterClientInit = () => {
+    afterInitlisteners.forEach(listener => {
+        globalVars.extensionInfo.pushSubscription(listener);
+    });
+}

vscode/src/extension.ts

@@ -25,11 +25,10 @@ export class ClientPromise {
     client!: Promise<NbLanguageClient>;
     activationPending: boolean = true;
 
-    public clientPromiseInitialization = (): void => {
+    public initialize = (): void => {
         this.client = new Promise<NbLanguageClient>((clientOK, clientErr) => {
             this.setClient = [
                 (c: NbLanguageClient) => {
-                    this.initialPromiseResolved = true;
                     clientOK(c);
                 },
                 (err: any) => {
@@ -71,7 +70,7 @@ export class ClientPromise {
         try {
             await this.stopClient();
             await nbProcessManager.killProcess(notifyKill);
-            this.clientPromiseInitialization();
+            this.initialize();
             initializeServer();
         } catch (error) {
             LOGGER.log(`Error during activation: ${error}`, LogLevel.ERROR);

vscode/src/listener.ts

@@ -24,7 +24,7 @@ import { extConstants, NODE_WINDOWS_LABEL } from "../constants";
 import { l10n } from "../localiser";
 import { window } from "vscode";
 import { ChildProcess } from "child_process";
-import { jdkDownloaderPrompt } from "../jdkDownloader/prompt";
+import { jdkDownloaderPrompt } from "../webviews/jdkDownloader/prompt";
 import * as os from 'os';
 import { LogLevel } from "../logger";
 import { isNbJavacDisabledHandler } from "../configurations/handlers";

vscode/src/lsp/clientPromise.ts

@@ -0,0 +1,135 @@
+/*
+  Copyright (c) 2023-2024, Oracle and/or its affiliates.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+import { LogMessageNotification, MessageType, TelemetryEventNotification } from "vscode-languageclient";
+import { notificationOrRequestListenerType } from "../types";
+import { asRanges, ShowStatusMessageParams, StatusMessageRequest, TestProgressNotification, TextEditorDecorationDisposeNotification, TextEditorDecorationSetNotification } from "../protocol";
+import { commands, window, workspace } from "vscode";
+import { isNbJavacDisabledHandler, updateConfigurationValue } from "../../configurations/handlers";
+import { l10n } from "../../localiser";
+import { configKeys } from "../../configurations/configuration";
+import { builtInCommands } from "../../commands/commands";
+import { globalVars, LOGGER } from "../../extension";
+
+const checkInstallNbJavac = (msg: string) => {
+    const NO_JAVA_SUPPORT = "Cannot initialize Java support";
+    if (msg.startsWith(NO_JAVA_SUPPORT)) {
+        if (isNbJavacDisabledHandler()) {
+            const message = l10n.value("jdk.extension.nbjavac.message.supportedVersionRequired");
+            const enable = l10n.value("jdk.extension.nbjavac.label.enableNbjavac");
+            const settings = l10n.value("jdk.extension.nbjavac.label.openSettings");
+            window.showErrorMessage(message, enable, settings).then(reply => {
+                if (enable === reply) {
+                    updateConfigurationValue(configKeys.disableNbJavac, false);
+                } else if (settings === reply) {
+                    commands.executeCommand(builtInCommands.openSettings, configKeys.jdkHome);
+                }
+            });
+        }
+    }
+}
+
+const showStatusBarMessageHandler = (params : ShowStatusMessageParams) => {
+    let decorated : string = params.message;
+    let defTimeout;
+
+    switch (params.type) {
+        case MessageType.Error:
+            decorated = '$(error) ' + params.message;
+            defTimeout = 0;
+            checkInstallNbJavac(params.message);
+            break;
+        case MessageType.Warning:
+            decorated = '$(warning) ' + params.message;
+            defTimeout = 0;
+            break;
+        default:
+            defTimeout = 10000;
+            break;
+    }
+    // params.timeout may be defined but 0 -> should be used
+    const timeout = params.timeout != undefined ? params.timeout : defTimeout;
+    if (timeout > 0) {
+        window.setStatusBarMessage(decorated, timeout);
+    } else {
+        window.setStatusBarMessage(decorated);
+    }
+}
+
+const logMessageHandler = (param: any) => {
+    LOGGER.log(param.message);
+}
+
+const testProgressHandler = (param: any) => {
+    if (globalVars.testAdapter) {
+        globalVars.testAdapter.testProgress(param.suite);
+    }
+}
+
+const textEditorSetDecorationHandler = (param: any) => {
+    let decorationType = globalVars.decorations.get(param.key);
+    if (decorationType) {
+        let editorsWithUri = window.visibleTextEditors.filter(
+            editor => editor.document.uri.toString() == param.uri
+        );
+        if (editorsWithUri.length > 0) {
+            editorsWithUri[0].setDecorations(decorationType, asRanges(param.ranges));
+            globalVars.decorationParamsByUri.set(editorsWithUri[0].document.uri, param);
+        }
+    }
+}
+
+const textEditorDecorationDisposeHandler = (param: any) => {
+    let decorationType = globalVars.decorations.get(param);
+    if (decorationType) {
+        globalVars.decorations.delete(param);
+        decorationType.dispose();
+        globalVars.decorationParamsByUri.forEach((value, key, map) => {
+            if (value.key == param) {
+                map.delete(key);
+            }
+        });
+    }
+}
+
+
+const telemetryEventHandler = (param: any) => {
+    const ls = globalVars.listeners.get(param);
+    if (ls) {
+        for (const listener of ls) {
+            commands.executeCommand(listener);
+        }
+    }
+}
+
+export const notificationListeners : notificationOrRequestListenerType[] = [{
+    type: StatusMessageRequest.type,
+    handler: showStatusBarMessageHandler
+}, {
+    type: LogMessageNotification.type,
+    handler: logMessageHandler
+}, {
+    type: TestProgressNotification.type,
+    handler: testProgressHandler
+},{
+    type: TextEditorDecorationSetNotification.type,
+    handler: textEditorSetDecorationHandler
+},{
+    type: TextEditorDecorationDisposeNotification.type,
+    handler: textEditorDecorationDisposeHandler
+},{
+    type: TelemetryEventNotification.type,
+    handler: telemetryEventHandler
+}];

vscode/src/lsp/initializer.ts

@@ -0,0 +1,25 @@
+/*
+  Copyright (c) 2023-2024, Oracle and/or its affiliates.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+import { NbLanguageClient } from "../nbLanguageClient"
+import { notificationOrRequestListenerType } from "../types"
+import { notificationListeners } from "./handlers"
+
+export const registerNotificationListeners = (client: NbLanguageClient) => {
+    notificationListeners.forEach((listener: notificationOrRequestListenerType) => {
+        const { type, handler } = listener;
+        client.onNotification(type, handler);
+    })
+}