chore: Some cleanup

src/config.ts

@@ -277,35 +277,35 @@ export class KubeConfig {
         if (!this.clusters) {
             this.clusters = [];
         }
-        this.clusters.forEach((c: Cluster, ix: number) => {
-            if (c.name === cluster.name) {
-                throw new Error(`Duplicate cluster: ${c.name}`);
-            }
-        });
+
+        if (this.clusters.some((c) => c.name === cluster.name)) {
+            throw new Error(`Duplicate cluster: ${cluster.name}`);
+        }
+
         this.clusters.push(cluster);
     }
 
     public addUser(user: User): void {
         if (!this.users) {
             this.users = [];
         }
-        this.users.forEach((c: User, ix: number) => {
-            if (c.name === user.name) {
-                throw new Error(`Duplicate user: ${c.name}`);
-            }
-        });
+
+        if (this.users.some((c) => c.name === user.name)) {
+            throw new Error(`Duplicate user: ${user.name}`);
+        }
+
         this.users.push(user);
     }
 
     public addContext(ctx: Context): void {
         if (!this.contexts) {
             this.contexts = [];
         }
-        this.contexts.forEach((c: Context, ix: number) => {
-            if (c.name === ctx.name) {
-                throw new Error(`Duplicate context: ${c.name}`);
-            }
-        });
+
+        if (this.contexts.some((c) => c.name === ctx.name)) {
+            throw new Error(`Duplicate context: ${ctx.name}`);
+        }
+
         this.contexts.push(ctx);
     }
 

src/exec_auth.ts

@@ -100,7 +100,7 @@ export class ExecAuth implements Authenticator {
             const env = {
                 ...process.env,
             };
-            exec.env.forEach((elt) => (env[elt.name] = elt.value));
+            exec.env.forEach((elt: { name: string | number; value?: string }) => (env[elt.name] = elt.value));
             opts = { ...opts, env };
         }
         const result = this.execFn(exec.command, exec.args, opts);

src/portforward.ts

@@ -1,7 +1,6 @@
 import WebSocket = require('isomorphic-ws');
 import querystring = require('querystring');
 import stream = require('stream');
-import { isUndefined } from 'util';
 
 import { KubeConfig } from './config';
 import { WebSocketHandler, WebSocketInterface } from './web-socket-handler';
@@ -13,7 +12,7 @@ export class PortForward {
     // handler is a parameter really only for injecting for testing.
     constructor(config: KubeConfig, disconnectOnErr?: boolean, handler?: WebSocketInterface) {
         this.handler = handler || new WebSocketHandler(config);
-        this.disconnectOnErr = isUndefined(disconnectOnErr) ? true : disconnectOnErr;
+        this.disconnectOnErr = disconnectOnErr === undefined ? true : disconnectOnErr;
     }
 
     // TODO: support multiple ports for real...

src/top.ts

@@ -1,10 +1,9 @@
 import { CoreV1Api, V1Node, V1Pod, V1PodList, V1PodStatus } from './gen/api';
-import { ContainerMetric, Metrics, PodMetric } from './metrics';
+import { Metrics, PodMetric } from './metrics';
 import {
     add,
     podsForNode,
     quantityToScalar,
-    ResourceStatus,
     totalCPU,
     totalCPUForContainer,
     totalMemory,
@@ -90,10 +89,7 @@ export async function topNodes(api: CoreV1Api): Promise<NodeStatus[]> {
 export async function topPods(api: CoreV1Api, metrics: Metrics, namespace?: string): Promise<PodStatus[]> {
     // Figure out which pod list endpoint to call
     const getPodList = async (): Promise<V1PodList> => {
-        if (namespace) {
-            return (await api.listNamespacedPod(namespace)).body;
-        }
-        return (await api.listPodForAllNamespaces()).body;
+        return (await (namespace ? api.listNamespacedPod(namespace) : api.listPodForAllNamespaces())).body;
     };
 
     const [podMetrics, podList] = await Promise.all([metrics.getPodMetrics(namespace), getPodList()]);

src/util.ts

@@ -30,52 +30,48 @@ export function quantityToScalar(quantity: string): number | bigint {
     }
     switch (suffix) {
         case 'n':
-            return Number(quantity.substr(0, quantity.length - 1)).valueOf() / 1_000_000_000.0;
+            return Number(quantity.slice(0, quantity.length - 1)).valueOf() / 1_000_000_000.0;
         case 'u':
-            return Number(quantity.substr(0, quantity.length - 1)).valueOf() / 1_000_000.0;
+            return Number(quantity.slice(0, quantity.length - 1)).valueOf() / 1_000_000.0;
         case 'm':
-            return Number(quantity.substr(0, quantity.length - 1)).valueOf() / 1000.0;
+            return Number(quantity.slice(0, quantity.length - 1)).valueOf() / 1000.0;
         case 'k':
-            return BigInt(quantity.substr(0, quantity.length - 1)) * BigInt(1000);
+            return BigInt(quantity.slice(0, quantity.length - 1)) * BigInt(1000);
         case 'M':
-            return BigInt(quantity.substr(0, quantity.length - 1)) * BigInt(1000 * 1000);
+            return BigInt(quantity.slice(0, quantity.length - 1)) * BigInt(1000 * 1000);
         case 'G':
-            return BigInt(quantity.substr(0, quantity.length - 1)) * BigInt(1000 * 1000 * 1000);
+            return BigInt(quantity.slice(0, quantity.length - 1)) * BigInt(1000 * 1000 * 1000);
         case 'T':
-            return (
-                BigInt(quantity.substr(0, quantity.length - 1)) * BigInt(1000 * 1000 * 1000) * BigInt(1000)
-            );
+            return BigInt(quantity.slice(0, quantity.length - 1)) * BigInt(1000 * 1000 * 1000) * BigInt(1000);
         case 'P':
             return (
-                BigInt(quantity.substr(0, quantity.length - 1)) *
+                BigInt(quantity.slice(0, quantity.length - 1)) *
                 BigInt(1000 * 1000 * 1000) *
                 BigInt(1000 * 1000)
             );
         case 'E':
             return (
-                BigInt(quantity.substr(0, quantity.length - 1)) *
+                BigInt(quantity.slice(0, quantity.length - 1)) *
                 BigInt(1000 * 1000 * 1000) *
                 BigInt(1000 * 1000 * 1000)
             );
         case 'Ki':
-            return BigInt(quantity.substr(0, quantity.length - 2)) * BigInt(1024);
+            return BigInt(quantity.slice(0, quantity.length - 2)) * BigInt(1024);
         case 'Mi':
-            return BigInt(quantity.substr(0, quantity.length - 2)) * BigInt(1024 * 1024);
+            return BigInt(quantity.slice(0, quantity.length - 2)) * BigInt(1024 * 1024);
         case 'Gi':
-            return BigInt(quantity.substr(0, quantity.length - 2)) * BigInt(1024 * 1024 * 1024);
+            return BigInt(quantity.slice(0, quantity.length - 2)) * BigInt(1024 * 1024 * 1024);
         case 'Ti':
-            return (
-                BigInt(quantity.substr(0, quantity.length - 2)) * BigInt(1024 * 1024 * 1024) * BigInt(1024)
-            );
+            return BigInt(quantity.slice(0, quantity.length - 2)) * BigInt(1024 * 1024 * 1024) * BigInt(1024);
         case 'Pi':
             return (
-                BigInt(quantity.substr(0, quantity.length - 2)) *
+                BigInt(quantity.slice(0, quantity.length - 2)) *
                 BigInt(1024 * 1024 * 1024) *
                 BigInt(1024 * 1024)
             );
         case 'Ei':
             return (
-                BigInt(quantity.substr(0, quantity.length - 2)) *
+                BigInt(quantity.slice(0, quantity.length - 2)) *
                 BigInt(1024 * 1024 * 1024) *
                 BigInt(1024 * 1024 * 1024)
             );

src/watch.ts

@@ -103,7 +103,7 @@ export class Watch {
         };
         await this.config.applyToRequest(requestOptions);
 
-        let req;
+        let req: RequestResult;
         let doneCalled: boolean = false;
         const doneCallOnce = (err: any) => {
             if (!doneCalled) {
@@ -122,7 +122,7 @@ export class Watch {
         stream.on('error', doneCallOnce);
         stream.on('close', () => doneCallOnce(null));
         stream.on('data', (line) => {
-            let data;
+            let data: { type: string; object: any };
 
             try {
                 data = JSON.parse(line);

src/web-socket-handler.ts

@@ -160,7 +160,7 @@ export class WebSocketHandler implements WebSocketInterface {
         }
         const server = cluster.server;
         const ssl = server.startsWith('https://');
-        const target = ssl ? server.substr(8) : server.substr(7);
+        const target = ssl ? server.slice(8) : server.slice(7);
         const proto = ssl ? 'wss' : 'ws';
         const uri = `${proto}://${target}${path}`;
 
@@ -193,7 +193,7 @@ export class WebSocketHandler implements WebSocketInterface {
                     }
                 } else if (data instanceof Buffer) {
                     const streamNum = data.readInt8(0);
-                    if (binaryHandler && !binaryHandler(streamNum, data.slice(1))) {
+                    if (binaryHandler && !binaryHandler(streamNum, data.subarray(1))) {
                         client.close();
                     }
                 }