Enforce semicolons in eslint

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

src/common/__tests__/cluster-store.test.ts

@@ -5,9 +5,9 @@ import { Cluster } from "../../main/cluster";
 import { ClusterStore } from "../cluster-store";
 import { workspaceStore } from "../workspace-store";
 
-const testDataIcon = fs.readFileSync("test-data/cluster-store-migration-icon.png")
+const testDataIcon = fs.readFileSync("test-data/cluster-store-migration-icon.png");
 
-console.log("") // fix bug
+console.log(""); // fix bug
 
 let clusterStore: ClusterStore;
 
@@ -18,15 +18,15 @@ describe("empty config", () => {
       'tmp': {
         'lens-cluster-store.json': JSON.stringify({})
       }
-    }
+    };
     mockFs(mockOpts);
     clusterStore = ClusterStore.getInstance<ClusterStore>();
     return clusterStore.load();
-  })
+  });
 
   afterEach(() => {
     mockFs.restore();
-  })
+  });
 
   describe("with foo cluster added", () => {
     beforeEach(() => {
@@ -43,30 +43,30 @@ describe("empty config", () => {
           workspace: workspaceStore.currentWorkspaceId
         })
       );
-    })
+    });
 
     it("adds new cluster to store", async () => {
       const storedCluster = clusterStore.getById("foo");
       expect(storedCluster.id).toBe("foo");
       expect(storedCluster.preferences.terminalCWD).toBe("/tmp");
       expect(storedCluster.preferences.icon).toBe("data:image/jpeg;base64, iVBORw0KGgoAAAANSUhEUgAAA1wAAAKoCAYAAABjkf5");
-    })
+    });
 
     it("adds cluster to default workspace", () => {
       const storedCluster = clusterStore.getById("foo");
       expect(storedCluster.workspace).toBe("default");
-    })
+    });
 
     it("removes cluster from store", async () => {
       await clusterStore.removeById("foo");
       expect(clusterStore.getById("foo")).toBeUndefined();
-    })
+    });
 
     it("sets active cluster", () => {
       clusterStore.setActive("foo");
       expect(clusterStore.active.id).toBe("foo");
-    })
-  })
+    });
+  });
 
   describe("with prod and dev clusters added", () => {
     beforeEach(() => {
@@ -89,8 +89,8 @@ describe("empty config", () => {
           kubeConfigPath: ClusterStore.embedCustomKubeConfig("dev", "fancy config"),
           workspace: "workstation"
         })
-      )
-    })
+      );
+    });
 
     it("check if store can contain multiple clusters", () => {
       expect(clusterStore.hasClusters()).toBeTruthy();
@@ -104,42 +104,42 @@ describe("empty config", () => {
       expect(wsClusters.length).toBe(2);
       expect(wsClusters[0].id).toBe("prod");
       expect(wsClusters[1].id).toBe("dev");
-    })
+    });
 
     it("check if cluster's kubeconfig file saved", () => {
       const file = ClusterStore.embedCustomKubeConfig("boo", "kubeconfig");
       expect(fs.readFileSync(file, "utf8")).toBe("kubeconfig");
-    })
+    });
 
     it("check if reorderring works for same from and to", () => {
-      clusterStore.swapIconOrders("workstation", 1, 1)
+      clusterStore.swapIconOrders("workstation", 1, 1);
 
       const clusters = clusterStore.getByWorkspaceId("workstation");
-      expect(clusters[0].id).toBe("prod")
-      expect(clusters[0].preferences.iconOrder).toBe(0)
-      expect(clusters[1].id).toBe("dev")
-      expect(clusters[1].preferences.iconOrder).toBe(1)
-    })
+      expect(clusters[0].id).toBe("prod");
+      expect(clusters[0].preferences.iconOrder).toBe(0);
+      expect(clusters[1].id).toBe("dev");
+      expect(clusters[1].preferences.iconOrder).toBe(1);
+    });
 
     it("check if reorderring works for different from and to", () => {
-      clusterStore.swapIconOrders("workstation", 0, 1)
+      clusterStore.swapIconOrders("workstation", 0, 1);
 
       const clusters = clusterStore.getByWorkspaceId("workstation");
-      expect(clusters[0].id).toBe("dev")
-      expect(clusters[0].preferences.iconOrder).toBe(0)
-      expect(clusters[1].id).toBe("prod")
-      expect(clusters[1].preferences.iconOrder).toBe(1)
-    })
+      expect(clusters[0].id).toBe("dev");
+      expect(clusters[0].preferences.iconOrder).toBe(0);
+      expect(clusters[1].id).toBe("prod");
+      expect(clusters[1].preferences.iconOrder).toBe(1);
+    });
 
     it("check if after icon reordering, changing workspaces still works", () => {
-      clusterStore.swapIconOrders("workstation", 1, 1)
-      clusterStore.getById("prod").workspace = "default"
+      clusterStore.swapIconOrders("workstation", 1, 1);
+      clusterStore.getById("prod").workspace = "default";
 
       expect(clusterStore.getByWorkspaceId("workstation").length).toBe(1);
       expect(clusterStore.getByWorkspaceId("default").length).toBe(1);
-    })
-  })
-})
+    });
+  });
+});
 
 describe("config with existing clusters", () => {
   beforeEach(() => {
@@ -176,21 +176,21 @@ describe("config with existing clusters", () => {
           ]
         })
       }
-    }
+    };
     mockFs(mockOpts);
     clusterStore = ClusterStore.getInstance<ClusterStore>();
     return clusterStore.load();
-  })
+  });
 
   afterEach(() => {
     mockFs.restore();
-  })
+  });
 
   it("allows to retrieve a cluster", () => {
     const storedCluster = clusterStore.getById('cluster1');
     expect(storedCluster.id).toBe('cluster1');
     expect(storedCluster.preferences.terminalCWD).toBe('/foo');
-  })
+  });
 
   it("allows to delete a cluster", () => {
     clusterStore.removeById('cluster2');
@@ -198,18 +198,18 @@ describe("config with existing clusters", () => {
     expect(storedCluster).toBeTruthy();
     const storedCluster2 = clusterStore.getById('cluster2');
     expect(storedCluster2).toBeUndefined();
-  })
+  });
 
   it("allows getting all of the clusters", async () => {
     const storedClusters = clusterStore.clustersList;
-    expect(storedClusters.length).toBe(3)
-    expect(storedClusters[0].id).toBe('cluster1')
-    expect(storedClusters[0].preferences.terminalCWD).toBe('/foo')
-    expect(storedClusters[1].id).toBe('cluster2')
-    expect(storedClusters[1].preferences.terminalCWD).toBe('/foo2')
-    expect(storedClusters[2].id).toBe('cluster3')
-  })
-})
+    expect(storedClusters.length).toBe(3);
+    expect(storedClusters[0].id).toBe('cluster1');
+    expect(storedClusters[0].preferences.terminalCWD).toBe('/foo');
+    expect(storedClusters[1].id).toBe('cluster2');
+    expect(storedClusters[1].preferences.terminalCWD).toBe('/foo2');
+    expect(storedClusters[2].id).toBe('cluster3');
+  });
+});
 
 describe("pre 2.0 config with an existing cluster", () => {
   beforeEach(() => {
@@ -229,17 +229,17 @@ describe("pre 2.0 config with an existing cluster", () => {
     mockFs(mockOpts);
     clusterStore = ClusterStore.getInstance<ClusterStore>();
     return clusterStore.load();
-  })
+  });
 
   afterEach(() => {
     mockFs.restore();
-  })
+  });
 
   it("migrates to modern format with kubeconfig in a file", async () => {
     const config = clusterStore.clustersList[0].kubeConfigPath;
     expect(fs.readFileSync(config, "utf8")).toBe("kubeconfig content");
-  })
-})
+  });
+});
 
 describe("pre 2.6.0 config with a cluster that has arrays in auth config", () => {
   beforeEach(() => {
@@ -257,15 +257,15 @@ describe("pre 2.6.0 config with a cluster that has arrays in auth config", () =>
           },
         })
       }
-    }
+    };
     mockFs(mockOpts);
     clusterStore = ClusterStore.getInstance<ClusterStore>();
     return clusterStore.load();
-  })
+  });
 
   afterEach(() => {
     mockFs.restore();
-  })
+  });
 
   it("replaces array format access token and expiry into string", async () => {
     const file = clusterStore.clustersList[0].kubeConfigPath;
@@ -273,8 +273,8 @@ describe("pre 2.6.0 config with a cluster that has arrays in auth config", () =>
     const kc = yaml.safeLoad(config);
     expect(kc.users[0].user['auth-provider'].config['access-token']).toBe("should be string");
     expect(kc.users[0].user['auth-provider'].config['expiry']).toBe("should be string");
-  })
-})
+  });
+});
 
 describe("pre 2.6.0 config with a cluster icon", () => {
   beforeEach(() => {
@@ -297,23 +297,23 @@ describe("pre 2.6.0 config with a cluster icon", () => {
         }),
         "icon_path": testDataIcon,
       }
-    }
+    };
     mockFs(mockOpts);
     clusterStore = ClusterStore.getInstance<ClusterStore>();
     return clusterStore.load();
-  })
+  });
 
   afterEach(() => {
     mockFs.restore();
-  })
+  });
 
   it("moves the icon into preferences", async () => {
     const storedClusterData = clusterStore.clustersList[0];
     expect(storedClusterData.hasOwnProperty('icon')).toBe(false);
     expect(storedClusterData.preferences.hasOwnProperty('icon')).toBe(true);
     expect(storedClusterData.preferences.icon.startsWith("data:;base64,")).toBe(true);
-  })
-})
+  });
+});
 
 describe("for a pre 2.7.0-beta.0 config without a workspace", () => {
   beforeEach(() => {
@@ -334,21 +334,21 @@ describe("for a pre 2.7.0-beta.0 config without a workspace", () => {
           },
         })
       }
-    }
+    };
     mockFs(mockOpts);
     clusterStore = ClusterStore.getInstance<ClusterStore>();
     return clusterStore.load();
-  })
+  });
 
   afterEach(() => {
     mockFs.restore();
-  })
+  });
 
   it("adds cluster to default workspace", async () => {
     const storedClusterData = clusterStore.clustersList[0];
     expect(storedClusterData.workspace).toBe('default');
-  })
-})
+  });
+});
 
 describe("pre 3.6.0-beta.1 config with an existing cluster", () => {
   beforeEach(() => {
@@ -378,19 +378,19 @@ describe("pre 3.6.0-beta.1 config with an existing cluster", () => {
     mockFs(mockOpts);
     clusterStore = ClusterStore.getInstance<ClusterStore>();
     return clusterStore.load();
-  })
+  });
 
   afterEach(() => {
     mockFs.restore();
-  })
+  });
 
   it("migrates to modern format with kubeconfig in a file", async () => {
     const config = clusterStore.clustersList[0].kubeConfigPath;
     expect(fs.readFileSync(config, "utf8")).toBe("kubeconfig content");
-  })
+  });
 
   it("migrates to modern format with icon not in file", async () => {
     const { icon } = clusterStore.clustersList[0].preferences;
     expect(icon.startsWith("data:;base64,")).toBe(true);
-  })
-})
+  });
+});

src/common/__tests__/event-bus.test.ts

@@ -1,15 +1,15 @@
-import { appEventBus, AppEvent } from "../event-bus"
+import { appEventBus, AppEvent } from "../event-bus";
 
 describe("event bus tests", () => {
   describe("emit", () => {
     it("emits an event", () => {
-      let event: AppEvent = null
+      let event: AppEvent = null;
       appEventBus.addListener((data) => {
-        event = data
-      })
+        event = data;
+      });
 
-      appEventBus.emit({name: "foo", action: "bar"})
-      expect(event.name).toBe("foo")
-    })
-  })
-})
+      appEventBus.emit({name: "foo", action: "bar"});
+      expect(event.name).toBe("foo");
+    });
+  });
+});

src/common/__tests__/search-store.test.ts

@@ -2,7 +2,7 @@
  * @jest-environment jsdom
  */
 
-import { SearchStore } from "../search-store"
+import { SearchStore } from "../search-store";
 
 let searchStore: SearchStore = null;
 
@@ -10,17 +10,17 @@ const logs = [
   "1:M 30 Oct 2020 16:17:41.553 # Connection with replica 172.17.0.12:6379 lost",
   "1:M 30 Oct 2020 16:17:41.623 * Replica 172.17.0.12:6379 asks for synchronization",
   "1:M 30 Oct 2020 16:17:41.623 * Starting Partial resynchronization request from 172.17.0.12:6379 accepted. Sending 0 bytes of backlog starting from offset 14407."
-]
+];
 
 describe("search store tests", () => {
   beforeEach(async () => {
     searchStore = new SearchStore();
-  })
+  });
 
   it("does nothing with empty search query", () => {
     searchStore.onSearch([], "");
     expect(searchStore.occurrences).toEqual([]);
-  })
+  });
 
   it("doesn't break if no text provided", () => {
     searchStore.onSearch(null, "replica");
@@ -28,53 +28,53 @@ describe("search store tests", () => {
 
     searchStore.onSearch([], "replica");
     expect(searchStore.occurrences).toEqual([]);
-  })
+  });
 
   it("find 3 occurences across 3 lines", () => {
     searchStore.onSearch(logs, "172");
     expect(searchStore.occurrences).toEqual([0, 1, 2]);
-  })
+  });
 
   it("find occurences within 1 line (case-insensitive)", () => {
     searchStore.onSearch(logs, "Starting");
     expect(searchStore.occurrences).toEqual([2, 2]);
-  })
+  });
 
   it("sets overlay index equal to first occurence", () => {
     searchStore.onSearch(logs, "Replica");
     expect(searchStore.activeOverlayIndex).toBe(0);
-  })
+  });
 
   it("set overlay index to next occurence", () => {
     searchStore.onSearch(logs, "172");
     searchStore.setNextOverlayActive();
     expect(searchStore.activeOverlayIndex).toBe(1);
-  })
+  });
 
   it("sets overlay to last occurence", () => {
     searchStore.onSearch(logs, "172");
     searchStore.setPrevOverlayActive();
     expect(searchStore.activeOverlayIndex).toBe(2);
-  })
+  });
 
   it("gets line index where overlay is located", () => {
     searchStore.onSearch(logs, "synchronization");
     expect(searchStore.activeOverlayLine).toBe(1);
-  })
+  });
 
   it("escapes string for using in regex", () => {
     const regex = searchStore.escapeRegex("some.interesting-query\\#?()[]");
     expect(regex).toBe("some\\.interesting\\-query\\\\\\#\\?\\(\\)\\[\\]");
-  })
+  });
 
   it("gets active find number", () => {
     searchStore.onSearch(logs, "172");
     searchStore.setNextOverlayActive();
     expect(searchStore.activeFind).toBe(2);
-  })
+  });
 
   it("gets total finds number", () => {
     searchStore.onSearch(logs, "Starting");
     expect(searchStore.totalFinds).toBe(2);
-  })
-})
+  });
+});

src/common/__tests__/user-store.test.ts

@@ -1,4 +1,4 @@
-import mockFs from "mock-fs"
+import mockFs from "mock-fs";
 
 jest.mock("electron", () => {
   return {
@@ -7,55 +7,55 @@ jest.mock("electron", () => {
       getPath: () => 'tmp',
       getLocale: () => 'en'
     }
-  }
-})
+  };
+});
 
-import { UserStore } from "../user-store"
-import { SemVer } from "semver"
-import electron from "electron"
+import { UserStore } from "../user-store";
+import { SemVer } from "semver";
+import electron from "electron";
 
 describe("user store tests", () => {
   describe("for an empty config", () => {
     beforeEach(() => {
-      UserStore.resetInstance()
-      mockFs({ tmp: { 'config.json': "{}" } })
-    })
+      UserStore.resetInstance();
+      mockFs({ tmp: { 'config.json': "{}" } });
+    });
 
     afterEach(() => {
-      mockFs.restore()
-    })
+      mockFs.restore();
+    });
 
     it("allows setting and retrieving lastSeenAppVersion", () => {
       const us = UserStore.getInstance<UserStore>();
 
       us.lastSeenAppVersion = "1.2.3";
       expect(us.lastSeenAppVersion).toBe("1.2.3");
-    })
+    });
 
     it("allows adding and listing seen contexts", () => {
       const us = UserStore.getInstance<UserStore>();
 
-      us.seenContexts.add('foo')
-      expect(us.seenContexts.size).toBe(1)
+      us.seenContexts.add('foo');
+      expect(us.seenContexts.size).toBe(1);
 
-      us.seenContexts.add('foo')
-      us.seenContexts.add('bar')
-      expect(us.seenContexts.size).toBe(2) // check 'foo' isn't added twice
-      expect(us.seenContexts.has('foo')).toBe(true)
-      expect(us.seenContexts.has('bar')).toBe(true)
-    })
+      us.seenContexts.add('foo');
+      us.seenContexts.add('bar');
+      expect(us.seenContexts.size).toBe(2); // check 'foo' isn't added twice
+      expect(us.seenContexts.has('foo')).toBe(true);
+      expect(us.seenContexts.has('bar')).toBe(true);
+    });
 
     it("allows setting and getting preferences", () => {
       const us = UserStore.getInstance<UserStore>();
 
       us.preferences.httpsProxy = 'abcd://defg';
 
-      expect(us.preferences.httpsProxy).toBe('abcd://defg')
-      expect(us.preferences.colorTheme).toBe(UserStore.defaultTheme)
+      expect(us.preferences.httpsProxy).toBe('abcd://defg');
+      expect(us.preferences.colorTheme).toBe(UserStore.defaultTheme);
 
       us.preferences.colorTheme = "light";
-      expect(us.preferences.colorTheme).toBe('light')
-    })
+      expect(us.preferences.colorTheme).toBe('light');
+    });
 
     it("correctly resets theme to default value", async () => {
       const us = UserStore.getInstance<UserStore>();
@@ -64,7 +64,7 @@ describe("user store tests", () => {
       us.preferences.colorTheme = "some other theme";
       await us.resetTheme();
       expect(us.preferences.colorTheme).toBe(UserStore.defaultTheme);
-    })
+    });
 
     it("correctly calculates if the last seen version is an old release", () => {
       const us = UserStore.getInstance<UserStore>();
@@ -73,12 +73,12 @@ describe("user store tests", () => {
 
       us.lastSeenAppVersion = (new SemVer(electron.app.getVersion())).inc("major").format();
       expect(us.isNewVersion).toBe(false);
-    })
-  })
+    });
+  });
 
   describe("migrations", () => {
     beforeEach(() => {
-      UserStore.resetInstance()
+      UserStore.resetInstance();
       mockFs({
         'tmp': {
           'config.json': JSON.stringify({
@@ -87,17 +87,17 @@ describe("user store tests", () => {
             lastSeenAppVersion: '1.2.3'
           })
         }
-      })
-    })
+      });
+    });
 
     afterEach(() => {
-      mockFs.restore()
-    })
+      mockFs.restore();
+    });
 
     it("sets last seen app version to 0.0.0", () => {
       const us = UserStore.getInstance<UserStore>();
 
-      expect(us.lastSeenAppVersion).toBe('0.0.0')
-    })
-  })
-})
+      expect(us.lastSeenAppVersion).toBe('0.0.0');
+    });
+  });
+});

src/common/__tests__/workspace-store.test.ts

@@ -1,4 +1,4 @@
-import mockFs from "mock-fs"
+import mockFs from "mock-fs";
 
 jest.mock("electron", () => {
   return {
@@ -7,36 +7,36 @@ jest.mock("electron", () => {
       getPath: () => 'tmp',
       getLocale: () => 'en'
     }
-  }
-})
+  };
+});
 
-import { Workspace, WorkspaceStore } from "../workspace-store"
+import { Workspace, WorkspaceStore } from "../workspace-store";
 
 describe("workspace store tests", () => {
   describe("for an empty config", () => {
     beforeEach(async () => {
-      WorkspaceStore.resetInstance()
-      mockFs({ tmp: { 'lens-workspace-store.json': "{}" } })
+      WorkspaceStore.resetInstance();
+      mockFs({ tmp: { 'lens-workspace-store.json': "{}" } });
 
       await WorkspaceStore.getInstance<WorkspaceStore>().load();
-    })
+    });
 
     afterEach(() => {
-      mockFs.restore()
-    })
+      mockFs.restore();
+    });
 
     it("default workspace should always exist", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
 
       expect(ws.workspaces.size).toBe(1);
       expect(ws.getById(WorkspaceStore.defaultId)).not.toBe(null);
-    })
+    });
 
     it("cannot remove the default workspace", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
 
       expect(() => ws.removeWorkspaceById(WorkspaceStore.defaultId)).toThrowError("Cannot remove");
-    })
+    });
 
     it("can update workspace description", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -50,7 +50,7 @@ describe("workspace store tests", () => {
       ws.updateWorkspace(workspace);
 
       expect(ws.getById("foobar").description).toBe("Foobar description");
-    })
+    });
 
     it("can add workspaces", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -61,13 +61,13 @@ describe("workspace store tests", () => {
       }));
 
       expect(ws.getById("123").name).toBe("foobar");
-    })
+    });
 
     it("cannot set a non-existent workspace to be active", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
 
       expect(() => ws.setActive("abc")).toThrow("doesn't exist");
-    })
+    });
 
     it("can set a existent workspace to be active", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -78,7 +78,7 @@ describe("workspace store tests", () => {
       }));
 
       expect(() => ws.setActive("abc")).not.toThrowError();
-    })
+    });
 
     it("can remove a workspace", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -94,7 +94,7 @@ describe("workspace store tests", () => {
       ws.removeWorkspaceById("123");
 
       expect(ws.workspaces.size).toBe(2);
-    })
+    });
 
     it("cannot create workspace with existent name", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -105,7 +105,7 @@ describe("workspace store tests", () => {
       }));
 
       expect(ws.workspacesList.length).toBe(1);  // default workspace only
-    })
+    });
 
     it("cannot create workspace with empty name", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -116,7 +116,7 @@ describe("workspace store tests", () => {
       }));
 
       expect(ws.workspacesList.length).toBe(1);  // default workspace only
-    })
+    });
 
     it("cannot create workspace with ' ' name", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -127,7 +127,7 @@ describe("workspace store tests", () => {
       }));
 
       expect(ws.workspacesList.length).toBe(1);  // default workspace only
-    })
+    });
 
     it("trim workspace name", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -138,12 +138,12 @@ describe("workspace store tests", () => {
       }));
 
       expect(ws.workspacesList.length).toBe(1);  // default workspace only
-    })
-  })
+    });
+  });
 
   describe("for a non-empty config", () => {
     beforeEach(async () => {
-      WorkspaceStore.resetInstance()
+      WorkspaceStore.resetInstance();
       mockFs({
         tmp: {
           'lens-workspace-store.json': JSON.stringify({
@@ -157,19 +157,19 @@ describe("workspace store tests", () => {
             }]
           })
         }
-      })
+      });
 
       await WorkspaceStore.getInstance<WorkspaceStore>().load();
-    })
+    });
 
     afterEach(() => {
-      mockFs.restore()
-    })
+      mockFs.restore();
+    });
 
     it("doesn't revert to default workspace", async () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
 
       expect(ws.currentWorkspaceId).toBe("abc");
-    })
-  })
-})
+    });
+  });
+});

src/common/base-store.ts

@@ -1,7 +1,7 @@
-import path from "path"
-import Config from "conf"
-import { Options as ConfOptions } from "conf/dist/source/types"
-import { app, ipcMain, IpcMainEvent, ipcRenderer, IpcRendererEvent, remote } from "electron"
+import path from "path";
+import Config from "conf";
+import { Options as ConfOptions } from "conf/dist/source/types";
+import { app, ipcMain, IpcMainEvent, ipcRenderer, IpcRendererEvent, remote } from "electron";
 import { action, IReactionOptions, observable, reaction, runInAction, toJS, when } from "mobx";
 import Singleton from "./utils/singleton";
 import { getAppVersion } from "./utils/app-version";
@@ -32,7 +32,7 @@ export abstract class BaseStore<T = any> extends Singleton {
       autoLoad: false,
       syncEnabled: true,
       ...params,
-    }
+    };
     this.init();
   }
 
@@ -41,11 +41,11 @@ export abstract class BaseStore<T = any> extends Singleton {
   }
 
   protected get syncRendererChannel() {
-    return `store-sync-renderer:${this.path}`
+    return `store-sync-renderer:${this.path}`;
   }
 
   protected get syncMainChannel() {
-    return `store-sync-main:${this.path}`
+    return `store-sync-main:${this.path}`;
   }
 
   get path() {
@@ -76,7 +76,7 @@ export abstract class BaseStore<T = any> extends Singleton {
   }
 
   protected cwd() {
-    return (app || remote.app).getPath("userData")
+    return (app || remote.app).getPath("userData");
   }
 
   protected async saveToFile(model: T) {
@@ -96,7 +96,7 @@ export abstract class BaseStore<T = any> extends Singleton {
         logger.silly(`[STORE]: SYNC ${this.name} from renderer`, { model });
         this.onSync(model);
       };
-      subscribeToBroadcast(this.syncMainChannel, callback)
+      subscribeToBroadcast(this.syncMainChannel, callback);
       this.syncDisposers.push(() => unsubscribeFromBroadcast(this.syncMainChannel, callback));
     }
     if (ipcRenderer) {
@@ -104,20 +104,20 @@ export abstract class BaseStore<T = any> extends Singleton {
         logger.silly(`[STORE]: SYNC ${this.name} from main`, { model });
         this.onSyncFromMain(model);
       };
-      subscribeToBroadcast(this.syncRendererChannel, callback)
+      subscribeToBroadcast(this.syncRendererChannel, callback);
       this.syncDisposers.push(() => unsubscribeFromBroadcast(this.syncRendererChannel, callback));
     }
   }
 
   protected onSyncFromMain(model: T) {
     this.applyWithoutSync(() => {
-      this.onSync(model)
-    })
+      this.onSync(model);
+    });
   }
 
   unregisterIpcListener() {
-    ipcRenderer.removeAllListeners(this.syncMainChannel)
-    ipcRenderer.removeAllListeners(this.syncRendererChannel)
+    ipcRenderer.removeAllListeners(this.syncMainChannel);
+    ipcRenderer.removeAllListeners(this.syncRendererChannel);
   }
 
   disableSync() {
@@ -143,9 +143,9 @@ export abstract class BaseStore<T = any> extends Singleton {
   protected async onModelChange(model: T) {
     if (ipcMain) {
       this.saveToFile(model); // save config file
-      broadcastMessage(this.syncRendererChannel, model)
+      broadcastMessage(this.syncRendererChannel, model);
     } else {
-      broadcastMessage(this.syncMainChannel, model)
+      broadcastMessage(this.syncMainChannel, model);
     }
   }
 

src/common/cluster-frames.ts

@@ -1,3 +1,3 @@
-import { observable } from "mobx"
+import { observable } from "mobx";
 
 export const clusterFrameMap = observable.map<string, number>();

src/common/cluster-ipc.ts

@@ -1,15 +1,15 @@
 import { handleRequest } from "./ipc";
 import { ClusterId, clusterStore } from "./cluster-store";
-import { appEventBus } from "./event-bus"
+import { appEventBus } from "./event-bus";
 import { ResourceApplier } from "../main/resource-applier";
 import { ipcMain } from "electron";
-import { clusterFrameMap } from "./cluster-frames"
+import { clusterFrameMap } from "./cluster-frames";
 
-export const clusterActivateHandler = "cluster:activate"
-export const clusterSetFrameIdHandler = "cluster:set-frame-id"
-export const clusterRefreshHandler = "cluster:refresh"
-export const clusterDisconnectHandler = "cluster:disconnect"
-export const clusterKubectlApplyAllHandler = "cluster:kubectl-apply-all"
+export const clusterActivateHandler = "cluster:activate";
+export const clusterSetFrameIdHandler = "cluster:set-frame-id";
+export const clusterRefreshHandler = "cluster:refresh";
+export const clusterDisconnectHandler = "cluster:disconnect";
+export const clusterKubectlApplyAllHandler = "cluster:kubectl-apply-all";
 
 
 if (ipcMain) {
@@ -18,38 +18,38 @@ if (ipcMain) {
     if (cluster) {
       return cluster.activate(force);
     }
-  })
+  });
 
   handleRequest(clusterSetFrameIdHandler, (event, clusterId: ClusterId, frameId: number) => {
     const cluster = clusterStore.getById(clusterId);
     if (cluster) {
-      clusterFrameMap.set(cluster.id, frameId)
+      clusterFrameMap.set(cluster.id, frameId);
       return cluster.pushState();
     }
-  })
+  });
 
   handleRequest(clusterRefreshHandler, (event, clusterId: ClusterId) => {
     const cluster = clusterStore.getById(clusterId);
-    if (cluster) return cluster.refresh({ refreshMetadata: true })
-  })
+    if (cluster) return cluster.refresh({ refreshMetadata: true });
+  });
 
   handleRequest(clusterDisconnectHandler, (event, clusterId: ClusterId) => {
     appEventBus.emit({name: "cluster", action: "stop"});
     const cluster = clusterStore.getById(clusterId);
     if (cluster) {
       cluster.disconnect();
-      clusterFrameMap.delete(cluster.id)
+      clusterFrameMap.delete(cluster.id);
     }
-  })
+  });
 
   handleRequest(clusterKubectlApplyAllHandler, (event, clusterId: ClusterId, resources: string[]) => {
-    appEventBus.emit({name: "cluster", action: "kubectl-apply-all"})
+    appEventBus.emit({name: "cluster", action: "kubectl-apply-all"});
     const cluster = clusterStore.getById(clusterId);
     if (cluster) {
-      const applier = new ResourceApplier(cluster)
-      applier.kubectlApplyAll(resources)
+      const applier = new ResourceApplier(cluster);
+      applier.kubectlApplyAll(resources);
     } else {
       throw `${clusterId} is not a valid cluster id`;
     }
-  })
+  });
 }

src/common/cluster-store.ts

@@ -5,9 +5,9 @@ import { unlink } from "fs-extra";
 import { action, computed, observable, reaction, toJS } from "mobx";
 import { BaseStore } from "./base-store";
 import { Cluster, ClusterState } from "../main/cluster";
-import migrations from "../migrations/cluster-store"
+import migrations from "../migrations/cluster-store";
 import logger from "../main/logger";
-import { appEventBus } from "./event-bus"
+import { appEventBus } from "./event-bus";
 import { dumpConfigYaml } from "./kube-helpers";
 import { saveToAppFiles } from "./utils/saveToAppFiles";
 import { KubeConfig } from "@kubernetes/client-node";
@@ -86,38 +86,38 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
       migrations: migrations,
     });
 
-    this.pushStateToViewsAutomatically()
+    this.pushStateToViewsAutomatically();
   }
 
   protected pushStateToViewsAutomatically() {
     if (!ipcRenderer) {
       reaction(() => this.connectedClustersList, () => {
-        this.pushState()
-      })
+        this.pushState();
+      });
     }
   }
 
   registerIpcListener() {
-    logger.info(`[CLUSTER-STORE] start to listen (${webFrame.routingId})`)
+    logger.info(`[CLUSTER-STORE] start to listen (${webFrame.routingId})`);
     subscribeToBroadcast("cluster:state", (event, clusterId: string, state: ClusterState) => {
       logger.silly(`[CLUSTER-STORE]: received push-state at ${location.host} (${webFrame.routingId})`, clusterId, state);
-      this.getById(clusterId)?.setState(state)
-    })
+      this.getById(clusterId)?.setState(state);
+    });
   }
 
   unregisterIpcListener() {
-    super.unregisterIpcListener()
-    unsubscribeAllFromBroadcast("cluster:state")
+    super.unregisterIpcListener();
+    unsubscribeAllFromBroadcast("cluster:state");
   }
 
   pushState() {
     this.clusters.forEach((c) => {
-      c.pushState()
-    })
+      c.pushState();
+    });
   }
 
   get activeClusterId() {
-    return this.activeCluster
+    return this.activeCluster;
   }
 
   @computed get clustersList(): Cluster[] {
@@ -125,7 +125,7 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
   }
 
   @computed get enabledClustersList(): Cluster[] {
-    return this.clustersList.filter((c) => c.enabled)
+    return this.clustersList.filter((c) => c.enabled);
   }
 
   @computed get active(): Cluster | null {
@@ -133,7 +133,7 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
   }
 
   @computed get connectedClustersList(): Cluster[] {
-    return this.clustersList.filter((c) => !c.disconnected)
+    return this.clustersList.filter((c) => !c.disconnected);
   }
 
   isActive(id: ClusterId) {
@@ -149,7 +149,7 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
   swapIconOrders(workspace: WorkspaceId, from: number, to: number) {
     const clusters = this.getByWorkspaceId(workspace);
     if (from < 0 || to < 0 || from >= clusters.length || to >= clusters.length || isNaN(from) || isNaN(to)) {
-      throw new Error(`invalid from<->to arguments`)
+      throw new Error(`invalid from<->to arguments`);
     }
 
     move.mutate(clusters, from, to);
@@ -170,37 +170,37 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
   getByWorkspaceId(workspaceId: string): Cluster[] {
     const clusters = Array.from(this.clusters.values())
       .filter(cluster => cluster.workspace === workspaceId);
-    return _.sortBy(clusters, cluster => cluster.preferences.iconOrder)
+    return _.sortBy(clusters, cluster => cluster.preferences.iconOrder);
   }
 
   @action
   addClusters(...models: ClusterModel[]): Cluster[] {
-    const clusters: Cluster[] = []
+    const clusters: Cluster[] = [];
     models.forEach(model => {
-      clusters.push(this.addCluster(model))
-    })
+      clusters.push(this.addCluster(model));
+    });
 
-    return clusters
+    return clusters;
   }
 
   @action
   addCluster(model: ClusterModel | Cluster): Cluster {
-    appEventBus.emit({ name: "cluster", action: "add" })
+    appEventBus.emit({ name: "cluster", action: "add" });
     let cluster = model as Cluster;
     if (!(model instanceof Cluster)) {
-      cluster = new Cluster(model)
+      cluster = new Cluster(model);
     }
     this.clusters.set(model.id, cluster);
-    return cluster
+    return cluster;
   }
 
   async removeCluster(model: ClusterModel) {
-    await this.removeById(model.id)
+    await this.removeById(model.id);
   }
 
   @action
   async removeById(clusterId: ClusterId) {
-    appEventBus.emit({ name: "cluster", action: "remove" })
+    appEventBus.emit({ name: "cluster", action: "remove" });
     const cluster = this.getById(clusterId);
     if (cluster) {
       this.clusters.delete(clusterId);
@@ -217,8 +217,8 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
   @action
   removeByWorkspaceId(workspaceId: string) {
     this.getByWorkspaceId(workspaceId).forEach(cluster => {
-      this.removeById(cluster.id)
-    })
+      this.removeById(cluster.id);
+    });
   }
 
   @action
@@ -235,7 +235,7 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
       } else {
         cluster = new Cluster(clusterModel);
         if (!cluster.isManaged) {
-          cluster.enabled = true
+          cluster.enabled = true;
         }
       }
       newClusters.set(clusterModel.id, cluster);
@@ -259,7 +259,7 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
       clusters: this.clustersList.map(cluster => cluster.toJSON()),
     }, {
       recurseEverything: true
-    })
+    });
   }
 }
 

src/common/event-bus.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from "./event-emitter"
+import { EventEmitter } from "./event-emitter";
 
 export type AppEvent = {
   name: string;
@@ -6,4 +6,4 @@ export type AppEvent = {
   params?: object;
 }
 
-export const appEventBus = new EventEmitter<[AppEvent]>()
+export const appEventBus = new EventEmitter<[AppEvent]>();

src/common/event-emitter.ts

@@ -35,6 +35,6 @@ export class EventEmitter<D extends [...any[]]> {
       const result = callback(...data);
       if (result === false) return; // break cycle
       return true;
-    })
+    });
   }
 }

src/common/ipc.ts

@@ -7,24 +7,24 @@ import logger from "../main/logger";
 import { clusterFrameMap } from "./cluster-frames";
 
 export function handleRequest(channel: string, listener: (...args: any[]) => any) {
-  ipcMain.handle(channel, listener)
+  ipcMain.handle(channel, listener);
 }
 
 export async function requestMain(channel: string, ...args: any[]) {
-  return ipcRenderer.invoke(channel, ...args)
+  return ipcRenderer.invoke(channel, ...args);
 }
 
 async function getSubFrames(): Promise<number[]> {
   const subFrames: number[] = [];
   clusterFrameMap.forEach((frameId, _) => {
-    subFrames.push(frameId)
+    subFrames.push(frameId);
   });
   return subFrames;
 }
 
 export function broadcastMessage(channel: string, ...args: any[]) {
   const views = (webContents || remote?.webContents)?.getAllWebContents();
-  if (!views) return
+  if (!views) return;
 
   views.forEach(webContent => {
     const type = webContent.getType();
@@ -32,39 +32,39 @@ export function broadcastMessage(channel: string, ...args: any[]) {
     webContent.send(channel, ...args);
     getSubFrames().then((frames) => {
       frames.map((frameId) => {
-        webContent.sendToFrame(frameId, channel, ...args)
-      })
-    }).catch((e) => e)
-  })
+        webContent.sendToFrame(frameId, channel, ...args);
+      });
+    }).catch((e) => e);
+  });
   if (ipcRenderer) {
-    ipcRenderer.send(channel, ...args)
+    ipcRenderer.send(channel, ...args);
   } else {
-    ipcMain.emit(channel, ...args)
+    ipcMain.emit(channel, ...args);
   }
 }
 
 export function subscribeToBroadcast(channel: string, listener: (...args: any[]) => any) {
   if (ipcRenderer) {
-    ipcRenderer.on(channel, listener)
+    ipcRenderer.on(channel, listener);
   } else {
-    ipcMain.on(channel, listener)
+    ipcMain.on(channel, listener);
   }
 
-  return listener
+  return listener;
 }
 
 export function unsubscribeFromBroadcast(channel: string, listener: (...args: any[]) => any) {
   if (ipcRenderer) {
-    ipcRenderer.off(channel, listener)
+    ipcRenderer.off(channel, listener);
   } else {
-    ipcMain.off(channel, listener)
+    ipcMain.off(channel, listener);
   }
 }
 
 export function unsubscribeAllFromBroadcast(channel: string) {
   if (ipcRenderer) {
-    ipcRenderer.removeAllListeners(channel)
+    ipcRenderer.removeAllListeners(channel);
   } else {
-    ipcMain.removeAllListeners(channel)
+    ipcMain.removeAllListeners(channel);
   }
 }

src/common/kube-helpers.ts

@@ -1,8 +1,8 @@
-import { KubeConfig, V1Node, V1Pod } from "@kubernetes/client-node"
+import { KubeConfig, V1Node, V1Pod } from "@kubernetes/client-node";
 import fse from "fs-extra";
-import path from "path"
-import os from "os"
-import yaml from "js-yaml"
+import path from "path";
+import os from "os";
+import yaml from "js-yaml";
 import logger from "../main/logger";
 import commandExists from "command-exists";
 import { ExecValidationNotFoundError } from "./custom-errors";
@@ -25,7 +25,7 @@ export function loadConfig(pathOrContent?: string): KubeConfig {
     kc.loadFromString(pathOrContent);
   }
 
-  return kc
+  return kc;
 }
 
 /**
@@ -39,33 +39,33 @@ export function validateConfig(config: KubeConfig | string): KubeConfig {
   if (typeof config == "string") {
     config = loadConfig(config);
   }
-  logger.debug(`validating kube config: ${JSON.stringify(config)}`)
+  logger.debug(`validating kube config: ${JSON.stringify(config)}`);
   if (!config.users || config.users.length == 0) {
-    throw new Error("No users provided in config")
+    throw new Error("No users provided in config");
   }
   if (!config.clusters || config.clusters.length == 0) {
-    throw new Error("No clusters provided in config")
+    throw new Error("No clusters provided in config");
   }
   if (!config.contexts || config.contexts.length == 0) {
-    throw new Error("No contexts provided in config")
+    throw new Error("No contexts provided in config");
   }
 
-  return config
+  return config;
 }
 
 /**
  * Breaks kube config into several configs. Each context as it own KubeConfig object
  */
 export function splitConfig(kubeConfig: KubeConfig): KubeConfig[] {
-  const configs: KubeConfig[] = []
+  const configs: KubeConfig[] = [];
   if (!kubeConfig.contexts) {
     return configs;
   }
   kubeConfig.contexts.forEach(ctx => {
     const kc = new KubeConfig();
     kc.clusters = [kubeConfig.getCluster(ctx.cluster)].filter(n => n);
-    kc.users = [kubeConfig.getUser(ctx.user)].filter(n => n)
-    kc.contexts = [kubeConfig.getContextObject(ctx.name)].filter(n => n)
+    kc.users = [kubeConfig.getUser(ctx.user)].filter(n => n);
+    kc.contexts = [kubeConfig.getContextObject(ctx.name)].filter(n => n);
     kc.setCurrentContext(ctx.name);
 
     configs.push(kc);
@@ -88,7 +88,7 @@ export function dumpConfigYaml(kubeConfig: Partial<KubeConfig>): string {
           server: cluster.server,
           'insecure-skip-tls-verify': cluster.skipTLSVerify
         }
-      }
+      };
     }),
     contexts: kubeConfig.contexts.map(context => {
       return {
@@ -98,7 +98,7 @@ export function dumpConfigYaml(kubeConfig: Partial<KubeConfig>): string {
           user: context.user,
           namespace: context.namespace
         }
-      }
+      };
     }),
     users: kubeConfig.users.map(user => {
       return {
@@ -114,9 +114,9 @@ export function dumpConfigYaml(kubeConfig: Partial<KubeConfig>): string {
           username: user.username,
           password: user.password
         }
-      }
+      };
     })
-  }
+  };
 
   logger.debug("Dumping KubeConfig:", config);
 
@@ -127,20 +127,20 @@ export function dumpConfigYaml(kubeConfig: Partial<KubeConfig>): string {
 export function podHasIssues(pod: V1Pod) {
   // Logic adapted from dashboard
   const notReady = !!pod.status.conditions.find(condition => {
-    return condition.type == "Ready" && condition.status !== "True"
+    return condition.type == "Ready" && condition.status !== "True";
   });
 
   return (
     notReady ||
     pod.status.phase !== "Running" ||
     pod.spec.priority > 500000 // We're interested in high prio pods events regardless of their running status
-  )
+  );
 }
 
 export function getNodeWarningConditions(node: V1Node) {
   return node.status.conditions.filter(c =>
     c.status.toLowerCase() === "true" && c.type !== "Ready" && c.type !== "HostUpgrades"
-  )
+  );
 }
 
 /**

src/common/prometheus-providers.ts

@@ -5,8 +5,8 @@ import { PrometheusStacklight } from "../main/prometheus/stacklight";
 import { PrometheusProviderRegistry } from "../main/prometheus/provider-registry";
 
 [PrometheusLens, PrometheusHelm, PrometheusOperator, PrometheusStacklight].forEach(providerClass => {
-  const provider = new providerClass()
-  PrometheusProviderRegistry.registerProvider(provider.id, provider)
+  const provider = new providerClass();
+  PrometheusProviderRegistry.registerProvider(provider.id, provider);
 });
 
-export const prometheusProviders = PrometheusProviderRegistry.getProviders()
+export const prometheusProviders = PrometheusProviderRegistry.getProviders();

src/common/register-protocol.ts

@@ -1,6 +1,6 @@
 // Register custom protocols
 
-import { protocol } from "electron"
+import { protocol } from "electron";
 import path from "path";
 
 export function registerFileProtocol(name: string, basePath: string) {
@@ -8,5 +8,5 @@ export function registerFileProtocol(name: string, basePath: string) {
     const filePath = request.url.replace(name + "://", "");
     const absPath = path.resolve(basePath, filePath);
     callback({ path: absPath });
-  })
+  });
 }

src/common/request.ts

@@ -1,28 +1,28 @@
-import request from "request"
-import requestPromise from "request-promise-native"
-import { userStore } from "./user-store"
+import request from "request";
+import requestPromise from "request-promise-native";
+import { userStore } from "./user-store";
 
 // todo: get rid of "request" (deprecated)
 // https://github.com/lensapp/lens/issues/459
 
 function getDefaultRequestOpts(): Partial<request.Options> {
-  const { httpsProxy, allowUntrustedCAs } = userStore.preferences
+  const { httpsProxy, allowUntrustedCAs } = userStore.preferences;
   return {
     proxy: httpsProxy || undefined,
     rejectUnauthorized: !allowUntrustedCAs,
-  }
+  };
 }
 
 /**
  * @deprecated
  */
 export function customRequest(opts: request.Options) {
-  return request.defaults(getDefaultRequestOpts())(opts)
+  return request.defaults(getDefaultRequestOpts())(opts);
 }
 
 /**
  * @deprecated
  */
 export function customRequestPromise(opts: requestPromise.Options) {
-  return requestPromise.defaults(getDefaultRequestOpts())(opts)
+  return requestPromise.defaults(getDefaultRequestOpts())(opts);
 }

src/common/system-ca.ts

@@ -1,14 +1,14 @@
 import { isMac, isWindows } from "./vars";
-import winca from "win-ca"
-import macca from "mac-ca"
-import logger from "../main/logger"
+import winca from "win-ca";
+import macca from "mac-ca";
+import logger from "../main/logger";
 
 if (isMac) {
   for (const crt of macca.all()) {
-    const attributes = crt.issuer?.attributes?.map((a: any) => `${a.name}=${a.value}`)
-    logger.debug("Using host CA: " + attributes.join(","))
+    const attributes = crt.issuer?.attributes?.map((a: any) => `${a.name}=${a.value}`);
+    logger.debug("Using host CA: " + attributes.join(","));
   }
 }
 if (isWindows) {
-  winca.inject("+") // see: https://github.com/ukoloff/win-ca#caveats
+  winca.inject("+"); // see: https://github.com/ukoloff/win-ca#caveats
 }

src/common/user-store.ts

@@ -1,13 +1,13 @@
 import type { ThemeId } from "../renderer/theme.store";
 import { app, remote } from 'electron';
-import semver from "semver"
-import { readFile } from "fs-extra"
+import semver from "semver";
+import { readFile } from "fs-extra";
 import { action, observable, reaction, toJS } from "mobx";
 import { BaseStore } from "./base-store";
-import migrations from "../migrations/user-store"
+import migrations from "../migrations/user-store";
 import { getAppVersion } from "./utils/app-version";
 import { kubeConfigDefaultPath, loadConfig } from "./kube-helpers";
-import { appEventBus } from "./event-bus"
+import { appEventBus } from "./event-bus";
 import logger from "../main/logger";
 import path from 'path';
 
@@ -66,7 +66,7 @@ export class UserStore extends BaseStore<UserStoreModel> {
     if (app) {
       // track telemetry availability
       reaction(() => this.preferences.allowTelemetry, allowed => {
-        appEventBus.emit({name: "telemetry", action: allowed ? "enabled" : "disabled"})
+        appEventBus.emit({name: "telemetry", action: allowed ? "enabled" : "disabled"});
       });
 
       // open at system start-up
@@ -95,7 +95,7 @@ export class UserStore extends BaseStore<UserStoreModel> {
 
   @action
   saveLastSeenAppVersion() {
-    appEventBus.emit({name: "app", action: "whats-new-seen"})
+    appEventBus.emit({name: "app", action: "whats-new-seen"});
     this.lastSeenAppVersion = getAppVersion();
   }
 
@@ -127,12 +127,12 @@ export class UserStore extends BaseStore<UserStoreModel> {
    * @returns string
    */
   getDefaultKubectlPath(): string {
-    return path.join((app || remote.app).getPath("userData"), "binaries")
+    return path.join((app || remote.app).getPath("userData"), "binaries");
   }
 
   @action
   protected async fromStore(data: Partial<UserStoreModel> = {}) {
-    const { lastSeenAppVersion, seenContexts = [], preferences, kubeConfigPath } = data
+    const { lastSeenAppVersion, seenContexts = [], preferences, kubeConfigPath } = data;
     if (lastSeenAppVersion) {
       this.lastSeenAppVersion = lastSeenAppVersion;
     }
@@ -149,10 +149,10 @@ export class UserStore extends BaseStore<UserStoreModel> {
       lastSeenAppVersion: this.lastSeenAppVersion,
       seenContexts: Array.from(this.seenContexts),
       preferences: this.preferences,
-    }
+    };
     return toJS(model, {
       recurseEverything: true,
-    })
+    });
   }
 }
 

src/common/utils/app-version.ts

@@ -1,4 +1,4 @@
-import packageInfo from "../../../package.json"
+import packageInfo from "../../../package.json";
 
 export function getAppVersion(): string {
   return packageInfo.version;
@@ -9,5 +9,5 @@ export function getBundledKubectlVersion(): string {
 }
 
 export function getBundledExtensions(): string[] {
-  return packageInfo.lens?.extensions || []
+  return packageInfo.lens?.extensions || [];
 }

src/common/utils/autobind.ts

@@ -6,7 +6,7 @@ export function autobind() {
   return function (target: Constructor | object, prop?: string, descriptor?: PropertyDescriptor) {
     if (target instanceof Function) return bindClass(target);
     else return bindMethod(target, prop, descriptor);
-  }
+  };
 }
 
 function bindClass<T extends Constructor>(constructor: T) {
@@ -22,12 +22,12 @@ function bindClass<T extends Constructor>(constructor: T) {
     if (skipMethod(prop)) return;
     const boundDescriptor = bindMethod(proto, prop, descriptors[prop]);
     Object.defineProperty(proto, prop, boundDescriptor);
-  })
+  });
 }
 
 function bindMethod(target: object, prop?: string, descriptor?: PropertyDescriptor) {
   if (!descriptor || typeof descriptor.value !== "function") {
-    throw new Error(`@autobind() must be used on class or method only`)
+    throw new Error(`@autobind() must be used on class or method only`);
   }
   const { value: func, enumerable, configurable } = descriptor;
   const boundFunc = new WeakMap<object, Function>();

src/common/utils/buildUrl.ts

@@ -1,4 +1,4 @@
-import { compile } from "path-to-regexp"
+import { compile } from "path-to-regexp";
 
 export interface IURLParams<P extends object = {}, Q extends object = {}> {
   params?: P;
@@ -8,7 +8,7 @@ export interface IURLParams<P extends object = {}, Q extends object = {}> {
 export function buildURL<P extends object = {}, Q extends object = {}>(path: string | any) {
   const pathBuilder = compile(String(path));
   return function ({ params, query }: IURLParams<P, Q> = {}) {
-    const queryParams = query ? new URLSearchParams(Object.entries(query)).toString() : ""
-    return pathBuilder(params) + (queryParams ? `?${queryParams}` : "")
-  }
+    const queryParams = query ? new URLSearchParams(Object.entries(query)).toString() : "";
+    return pathBuilder(params) + (queryParams ? `?${queryParams}` : "");
+  };
 }

src/common/utils/defineGlobal.ts

@@ -5,7 +5,7 @@
 export function defineGlobal(propName: string, descriptor: PropertyDescriptor) {
   const scope = typeof global !== "undefined" ? global : window;
   if (scope.hasOwnProperty(propName)) {
-    console.info(`Global variable "${propName}" already exists. Skipping.`)
+    console.info(`Global variable "${propName}" already exists. Skipping.`);
     return;
   }
   Object.defineProperty(scope, propName, descriptor);

src/common/utils/index.ts

@@ -1,14 +1,14 @@
 // Common utils (main OR renderer)
 
-export * from "./app-version"
-export * from "./autobind"
-export * from "./base64"
-export * from "./camelCase"
-export * from "./cloneJson"
-export * from "./debouncePromise"
-export * from "./defineGlobal"
-export * from "./getRandId"
-export * from "./splitArray"
-export * from "./saveToAppFiles"
-export * from "./singleton"
-export * from "./openExternal"
+export * from "./app-version";
+export * from "./autobind";
+export * from "./base64";
+export * from "./camelCase";
+export * from "./cloneJson";
+export * from "./debouncePromise";
+export * from "./defineGlobal";
+export * from "./getRandId";
+export * from "./splitArray";
+export * from "./saveToAppFiles";
+export * from "./singleton";
+export * from "./openExternal";

src/common/utils/openExternal.ts

@@ -1,5 +1,5 @@
 // Opens a link in external browser
-import { shell } from "electron"
+import { shell } from "electron";
 
 export function openExternal(url: string) {
   return shell.openExternal(url);

src/common/utils/saveToAppFiles.ts

@@ -2,7 +2,7 @@
 import path from "path";
 import { app, remote } from "electron";
 import { ensureDirSync, writeFileSync } from "fs-extra";
-import { WriteFileOptions } from "fs"
+import { WriteFileOptions } from "fs";
 
 export function saveToAppFiles(filePath: string, contents: any, options?: WriteFileOptions): string {
   const absPath = path.resolve((app || remote.app).getPath("userData"), filePath);

src/common/utils/singleton.ts

@@ -24,5 +24,5 @@ class Singleton {
   }
 }
 
-export { Singleton }
+export { Singleton };
 export default Singleton;

src/common/utils/splitArray.ts

@@ -15,5 +15,5 @@ export function splitArray<T>(array: T[], element: T): [T[], T[], boolean] {
   if (index < 0) {
     return [array, [], false];
   }
-  return [array.slice(0, index), array.slice(index + 1, array.length), true]
+  return [array.slice(0, index), array.slice(index + 1, array.length), true];
 }

src/common/vars.ts

@@ -1,19 +1,19 @@
 // App's common configuration for any process (main, renderer, build pipeline, etc.)
 import path from "path";
-import packageInfo from "../../package.json"
+import packageInfo from "../../package.json";
 import { defineGlobal } from "./utils/defineGlobal";
 
-export const isMac = process.platform === "darwin"
-export const isWindows = process.platform === "win32"
-export const isLinux = process.platform === "linux"
+export const isMac = process.platform === "darwin";
+export const isWindows = process.platform === "win32";
+export const isLinux = process.platform === "linux";
 export const isDebugging = process.env.DEBUG === "true";
-export const isSnap = !!process.env["SNAP"]
-export const isProduction = process.env.NODE_ENV === "production"
+export const isSnap = !!process.env["SNAP"];
+export const isProduction = process.env.NODE_ENV === "production";
 export const isTestEnv = !!process.env.JEST_WORKER_ID;
 export const isDevelopment = !isTestEnv && !isProduction;
 
-export const appName = `${packageInfo.productName}${isDevelopment ? "Dev" : ""}`
-export const publicPath = "/build/"
+export const appName = `${packageInfo.productName}${isDevelopment ? "Dev" : ""}`;
+export const publicPath = "/build/";
 
 // Webpack build paths
 export const contextDir = process.cwd();
@@ -22,7 +22,7 @@ export const mainDir = path.join(contextDir, "src/main");
 export const rendererDir = path.join(contextDir, "src/renderer");
 export const htmlTemplate = path.resolve(rendererDir, "template.html");
 export const sassCommonVars = path.resolve(rendererDir, "components/vars.scss");
-export const webpackDevServerPort = 9009
+export const webpackDevServerPort = 9009;
 
 // Special runtime paths
 defineGlobal("__static", {
@@ -30,14 +30,14 @@ defineGlobal("__static", {
     if (isDevelopment) {
       return path.resolve(contextDir, "static");
     }
-    return path.resolve(process.resourcesPath, "static")
+    return path.resolve(process.resourcesPath, "static");
   }
-})
+});
 
 // Apis
-export const apiPrefix = "/api" // local router apis
-export const apiKubePrefix = "/api-kube" // k8s cluster apis
+export const apiPrefix = "/api"; // local router apis
+export const apiKubePrefix = "/api-kube"; // k8s cluster apis
 
 // Links
-export const issuesTrackerUrl = "https://github.com/lensapp/lens/issues"
-export const slackUrl = "https://join.slack.com/t/k8slens/shared_invite/enQtOTc5NjAyNjYyOTk4LWU1NDQ0ZGFkOWJkNTRhYTc2YjVmZDdkM2FkNGM5MjhiYTRhMDU2NDQ1MzIyMDA4ZGZlNmExOTc0N2JmY2M3ZGI"
+export const issuesTrackerUrl = "https://github.com/lensapp/lens/issues";
+export const slackUrl = "https://join.slack.com/t/k8slens/shared_invite/enQtOTc5NjAyNjYyOTk4LWU1NDQ0ZGFkOWJkNTRhYTc2YjVmZDdkM2FkNGM5MjhiYTRhMDU2NDQ1MzIyMDA4ZGZlNmExOTc0N2JmY2M3ZGI";

src/common/workspace-store.ts

@@ -1,7 +1,7 @@
 import { ipcRenderer } from "electron";
 import { action, computed, observable, toJS, reaction } from "mobx";
 import { BaseStore } from "./base-store";
-import { clusterStore } from "./cluster-store"
+import { clusterStore } from "./cluster-store";
 import { appEventBus } from "./event-bus";
 import { broadcastMessage } from "../common/ipc";
 import logger from "../main/logger";
@@ -32,33 +32,33 @@ export class Workspace implements WorkspaceModel, WorkspaceState {
   @observable enabled: boolean
 
   constructor(data: WorkspaceModel) {
-    Object.assign(this, data)
+    Object.assign(this, data);
 
     if (!ipcRenderer) {
       reaction(() => this.getState(), () => {
-        this.pushState()
-      })
+        this.pushState();
+      });
     }
   }
 
   get isManaged(): boolean {
-    return !!this.ownerRef
+    return !!this.ownerRef;
   }
 
   getState(): WorkspaceState {
     return {
       enabled: this.enabled
-    }
+    };
   }
 
   pushState(state = this.getState()) {
-    logger.silly("[WORKSPACE] pushing state", {...state, id: this.id})
-    broadcastMessage("workspace:state", this.id, toJS(state))
+    logger.silly("[WORKSPACE] pushing state", {...state, id: this.id});
+    broadcastMessage("workspace:state", this.id, toJS(state));
   }
 
   @action
   setState(state: WorkspaceState) {
-    Object.assign(this, state)
+    Object.assign(this, state);
   }
 
   toJSON(): WorkspaceModel {
@@ -67,7 +67,7 @@ export class Workspace implements WorkspaceModel, WorkspaceState {
       name: this.name,
       description: this.description,
       ownerRef: this.ownerRef
-    })
+    });
   }
 }
 
@@ -81,21 +81,21 @@ export class WorkspaceStore extends BaseStore<WorkspaceStoreModel> {
 
     if (!ipcRenderer) {
       setInterval(() => {
-        this.pushState()
-      }, 5000)
+        this.pushState();
+      }, 5000);
     }
   }
 
   registerIpcListener() {
-    logger.info("[WORKSPACE-STORE] starting to listen state events")
+    logger.info("[WORKSPACE-STORE] starting to listen state events");
     ipcRenderer.on("workspace:state", (event, workspaceId: string, state: WorkspaceState) => {
-      this.getById(workspaceId)?.setState(state)
-    })
+      this.getById(workspaceId)?.setState(state);
+    });
   }
 
   unregisterIpcListener() {
-    super.unregisterIpcListener()
-    ipcRenderer.removeAllListeners("workspace:state")
+    super.unregisterIpcListener();
+    ipcRenderer.removeAllListeners("workspace:state");
   }
 
   @observable currentWorkspaceId = WorkspaceStore.defaultId;
@@ -121,8 +121,8 @@ export class WorkspaceStore extends BaseStore<WorkspaceStoreModel> {
 
   pushState() {
     this.workspaces.forEach((w) => {
-      w.pushState()
-    })
+      w.pushState();
+    });
   }
 
   isDefault(id: WorkspaceId) {
@@ -154,7 +154,7 @@ export class WorkspaceStore extends BaseStore<WorkspaceStoreModel> {
       return;
     }
     this.workspaces.set(id, workspace);
-    appEventBus.emit({name: "workspace", action: "add"})
+    appEventBus.emit({name: "workspace", action: "add"});
     return workspace;
   }
 
@@ -166,7 +166,7 @@ export class WorkspaceStore extends BaseStore<WorkspaceStoreModel> {
 
   @action
   removeWorkspace(workspace: Workspace) {
-    this.removeWorkspaceById(workspace.id)
+    this.removeWorkspaceById(workspace.id);
   }
 
   @action
@@ -180,24 +180,24 @@ export class WorkspaceStore extends BaseStore<WorkspaceStoreModel> {
       this.currentWorkspaceId = WorkspaceStore.defaultId; // reset to default
     }
     this.workspaces.delete(id);
-    appEventBus.emit({name: "workspace", action: "remove"})
-    clusterStore.removeByWorkspaceId(id)
+    appEventBus.emit({name: "workspace", action: "remove"});
+    clusterStore.removeByWorkspaceId(id);
   }
 
   @action
   protected fromStore({ currentWorkspace, workspaces = [] }: WorkspaceStoreModel) {
     if (currentWorkspace) {
-      this.currentWorkspaceId = currentWorkspace
+      this.currentWorkspaceId = currentWorkspace;
     }
     if (workspaces.length) {
       this.workspaces.clear();
       workspaces.forEach(ws => {
-        const workspace = new Workspace(ws)
+        const workspace = new Workspace(ws);
         if (!workspace.isManaged) {
-          workspace.enabled = true
+          workspace.enabled = true;
         }
-        this.workspaces.set(workspace.id, workspace)
-      })
+        this.workspaces.set(workspace.id, workspace);
+      });
     }
   }
 
@@ -207,8 +207,8 @@ export class WorkspaceStore extends BaseStore<WorkspaceStoreModel> {
       workspaces: this.workspacesList.map((w) => w.toJSON()),
     }, {
       recurseEverything: true
-    })
+    });
   }
 }
 
-export const workspaceStore = WorkspaceStore.getInstance<WorkspaceStore>()
+export const workspaceStore = WorkspaceStore.getInstance<WorkspaceStore>();