Add a few missing folders to be linted.

Signed-off-by: Panu Horsmalahti <phorsmalahti@mirantis.com>

extensions/telemetry/src/telemetry-preference.tsx

@@ -1,19 +1,19 @@
-import { Component } from "@k8slens/extensions"
-import React from "react"
+import { Component } from "@k8slens/extensions";
+import React from "react";
 import { observer } from "mobx-react";
-import { TelemetryPreferencesStore } from "./telemetry-preferences-store"
+import { TelemetryPreferencesStore } from "./telemetry-preferences-store";
 
 @observer
 export class TelemetryPreferenceInput extends React.Component<{telemetry: TelemetryPreferencesStore}, {}> {
   render() {
-    const { telemetry } = this.props
+    const { telemetry } = this.props;
     return (
       <Component.Checkbox
         label="Allow telemetry & usage tracking"
         value={telemetry.enabled}
         onChange={v => { telemetry.enabled = v; }}
       />
-    )
+    );
   }
 }
 
@@ -21,6 +21,6 @@ export class TelemetryPreferenceHint extends React.Component {
   render() {
     return (
       <span>Telemetry & usage data is collected to continuously improve the Lens experience.</span>
-    )
+    );
   }
 }

extensions/telemetry/src/telemetry-preferences-store.ts

@@ -1,5 +1,5 @@
 import { Store } from "@k8slens/extensions";
-import { toJS } from "mobx"
+import { toJS } from "mobx";
 
 export type TelemetryPreferencesModel = {
   enabled: boolean;
@@ -14,11 +14,11 @@ export class TelemetryPreferencesStore extends Store.ExtensionStore<TelemetryPre
       defaults: {
         enabled: true
       }
-    })
+    });
   }
 
   protected fromStore({ enabled }: TelemetryPreferencesModel): void {
-    this.enabled = enabled
+    this.enabled = enabled;
   }
 
   toJSON(): TelemetryPreferencesModel {
@@ -26,8 +26,8 @@ export class TelemetryPreferencesStore extends Store.ExtensionStore<TelemetryPre
       enabled: this.enabled
     }, {
       recurseEverything: true
-    })
+    });
   }
 }
 
-export const telemetryPreferencesStore = TelemetryPreferencesStore.getInstance<TelemetryPreferencesStore>()
+export const telemetryPreferencesStore = TelemetryPreferencesStore.getInstance<TelemetryPreferencesStore>();

extensions/telemetry/src/tracker.ts

@@ -1,8 +1,8 @@
-import { EventBus, Util, Store, App } from "@k8slens/extensions"
-import ua from "universal-analytics"
-import Analytics from "analytics-node"
-import { machineIdSync } from "node-machine-id"
-import { telemetryPreferencesStore } from "./telemetry-preferences-store"
+import { EventBus, Util, Store, App } from "@k8slens/extensions";
+import ua from "universal-analytics";
+import Analytics from "analytics-node";
+import { machineIdSync } from "node-machine-id";
+import { telemetryPreferencesStore } from "./telemetry-preferences-store";
 
 export class Tracker extends Util.Singleton {
   static readonly GA_ID = "UA-159377374-1"
@@ -23,69 +23,69 @@ export class Tracker extends Util.Singleton {
 
   private constructor() {
     super();
-    this.anonymousId = machineIdSync()
-    this.os = this.resolveOS()
-    this.userAgent = `Lens ${App.version} (${this.os})`
+    this.anonymousId = machineIdSync();
+    this.os = this.resolveOS();
+    this.userAgent = `Lens ${App.version} (${this.os})`;
     try {
-      this.visitor = ua(Tracker.GA_ID, this.anonymousId, { strictCidFormat: false })
+      this.visitor = ua(Tracker.GA_ID, this.anonymousId, { strictCidFormat: false });
     } catch (error) {
-      this.visitor = ua(Tracker.GA_ID)
+      this.visitor = ua(Tracker.GA_ID);
     }
 
-    this.analytics = new Analytics(Tracker.SEGMENT_KEY, { flushAt: 1 })
-    this.visitor.set("dl", "https://telemetry.k8slens.dev")
-    this.visitor.set("ua", this.userAgent)
+    this.analytics = new Analytics(Tracker.SEGMENT_KEY, { flushAt: 1 });
+    this.visitor.set("dl", "https://telemetry.k8slens.dev");
+    this.visitor.set("ua", this.userAgent);
   }
 
   start() {
-    if (this.started === true) { return }
+    if (this.started === true) { return; }
 
-    this.started = true
+    this.started = true;
 
     const handler = (ev: EventBus.AppEvent) => {
-      this.event(ev.name, ev.action, ev.params)
-    }
-    this.eventHandlers.push(handler)
-    EventBus.appEventBus.addListener(handler)
+      this.event(ev.name, ev.action, ev.params);
+    };
+    this.eventHandlers.push(handler);
+    EventBus.appEventBus.addListener(handler);
   }
 
   reportPeriodically() {
     this.reportInterval = setInterval(() => {
-      this.reportData()
-    }, 60 * 60 * 1000) // report every 1h
+      this.reportData();
+    }, 60 * 60 * 1000); // report every 1h
   }
 
   stop() {
-    if (!this.started) { return }
+    if (!this.started) { return; }
 
-    this.started = false
+    this.started = false;
 
     for (const handler of this.eventHandlers) {
-      EventBus.appEventBus.removeListener(handler)
+      EventBus.appEventBus.removeListener(handler);
     }
     if (this.reportInterval) {
-      clearInterval(this.reportInterval)
+      clearInterval(this.reportInterval);
     }
   }
 
   protected async isTelemetryAllowed(): Promise<boolean> {
-    return telemetryPreferencesStore.enabled
+    return telemetryPreferencesStore.enabled;
   }
 
   protected reportData() {
-    const clustersList = Store.clusterStore.enabledClustersList
+    const clustersList = Store.clusterStore.enabledClustersList;
 
     this.event("generic-data", "report", {
       appVersion: App.version,
       os: this.os,
       clustersCount: clustersList.length,
       workspacesCount: Store.workspaceStore.enabledWorkspacesList.length
-    })
+    });
 
     clustersList.forEach((cluster) => {
-      if (!cluster?.metadata.lastSeen) { return }
-      this.reportClusterData(cluster)
-    })
+      if (!cluster?.metadata.lastSeen) { return; }
+      this.reportClusterData(cluster);
+    });
   }
 
   protected reportClusterData(cluster: Store.ClusterModel) {
@@ -96,26 +96,26 @@ export class Tracker extends Util.Singleton {
       distribution: cluster.metadata.distribution,
       nodesCount: cluster.metadata.nodes,
       lastSeen: cluster.metadata.lastSeen
-    })
+    });
   }
 
   protected resolveOS() {
-    let os = ""
+    let os = "";
     if (App.isMac) {
-      os = "MacOS"
+      os = "MacOS";
     } else if(App.isWindows) {
-      os = "Windows"
+      os = "Windows";
     } else if (App.isLinux) {
-      os = "Linux"
+      os = "Linux";
       if (App.isSnap) {
-        os += "; Snap"
+        os += "; Snap";
       } else {
-        os += "; AppImage"
+        os += "; AppImage";
       }
     } else {
-      os = "Unknown"
+      os = "Unknown";
     }
-    return os
+    return os;
   }
 
   protected async event(eventCategory: string, eventAction: string, otherParams = {}) {
@@ -128,7 +128,7 @@ export class Tracker extends Util.Singleton {
         ec: eventCategory,
         ea: eventAction,
         ...otherParams,
-      }).send()
+      }).send();
 
       this.analytics.track({
         anonymousId: this.anonymousId,
@@ -141,9 +141,9 @@ export class Tracker extends Util.Singleton {
           ...otherParams,
         },
 
-      })
+      });
     } catch (err) {
-      console.error(`Failed to track "${eventCategory}:${eventAction}"`, err)
+      console.error(`Failed to track "${eventCategory}:${eventAction}"`, err);
     }
   }
 }