Adapt to changes in injectable

Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com>
Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>

src/extensions/extension-loader/extension-loader.injectable.ts

@@ -18,14 +18,13 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { lifecycleEnum } from "@ogre-tools/injectable";
 import { ExtensionLoader } from "./extension-loader";
 
-const extensionLoaderInjectable: Injectable<ExtensionLoader> = {
+const extensionLoaderInjectable = getInjectable({
-  getDependencies: () => ({}),
   instantiate: () => new ExtensionLoader(),
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default extensionLoaderInjectable;

src/extensions/extensions.injectable.ts

@@ -18,24 +18,18 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import { Injectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { computed, IComputedValue } from "mobx";
+import { computed } from "mobx";
-import type { LensExtension } from "./lens-extension";
-import type { ExtensionLoader } from "./extension-loader";
 import extensionLoaderInjectable from "./extension-loader/extension-loader.injectable";
 
-const extensionsInjectable: Injectable<
+const extensionsInjectable = getInjectable({
-  IComputedValue<LensExtension[]>,
+  instantiate: (di) => {
-  { extensionLoader: ExtensionLoader }
+    const extensionLoader = di.inject(extensionLoaderInjectable);
-> = {
+
-  getDependencies: di => ({
+    return computed(() => extensionLoader.enabledExtensionInstances);
-    extensionLoader: di.inject(extensionLoaderInjectable),
+  },
-  }),
 
   lifecycle: lifecycleEnum.singleton,
-
+});
-  instantiate: ({ extensionLoader }) =>
-    computed(() => extensionLoader.enabledExtensionInstances),
-};
 
 export default extensionsInjectable;

src/extensions/main-extensions.injectable.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2021 OpenLens Authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import type { IComputedValue } from "mobx";
+import extensionsInjectable from "./extensions.injectable";
+import type { LensMainExtension } from "./lens-main-extension";
+
+const mainExtensionsInjectable = getInjectable({
+  lifecycle: lifecycleEnum.singleton,
+
+  instantiate: (di) =>
+    di.inject(extensionsInjectable) as IComputedValue<LensMainExtension[]>,
+});
+
+export default mainExtensionsInjectable;

src/main/menu/electron-menu-items.injectable.ts

@@ -18,24 +18,20 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import { Injectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { computed, IComputedValue } from "mobx";
+import { computed } from "mobx";
-import type { LensMainExtension } from "../../extensions/lens-main-extension";
+import mainExtensionsInjectable from "../../extensions/main-extensions.injectable";
-import extensionsInjectable from "../../extensions/extensions.injectable";
-import type { MenuRegistration } from "./menu-registration";
 
-const electronMenuItemsInjectable: Injectable<
+const electronMenuItemsInjectable = getInjectable({
-  IComputedValue<MenuRegistration[]>,
-  { extensions: IComputedValue<LensMainExtension[]> }
-> = {
   lifecycle: lifecycleEnum.singleton,
 
-  getDependencies: di => ({
+  instantiate: (di) => {
-    extensions: di.inject(extensionsInjectable),
+    const extensions = di.inject(mainExtensionsInjectable);
-  }),
 
-  instantiate: ({ extensions }) =>
+    return computed(() =>
-    computed(() => extensions.get().flatMap(extension => extension.appMenus)),
+      extensions.get().flatMap((extension) => extension.appMenus),
-};
+    );
+  },
+});
 
 export default electronMenuItemsInjectable;

src/main/menu/electron-menu-items.test.ts

@@ -24,8 +24,8 @@ import electronMenuItemsInjectable from "./electron-menu-items.injectable";
 import type { IComputedValue } from "mobx";
 import { computed, ObservableMap, runInAction } from "mobx";
 import type { MenuRegistration } from "./menu-registration";
-import extensionsInjectable from "../../extensions/extensions.injectable";
 import { getDiForUnitTesting } from "../getDiForUnitTesting";
+import mainExtensionsInjectable from "../../extensions/main-extensions.injectable";
 
 describe("electron-menu-items", () => {
   let di: ConfigurableDependencyInjectionContainer;
@@ -38,8 +38,8 @@ describe("electron-menu-items", () => {
     extensionsStub = new ObservableMap();
 
     di.override(
-      extensionsInjectable,
+      mainExtensionsInjectable,
-      computed(() => [...extensionsStub.values()]),
+      () => computed(() => [...extensionsStub.values()]),
     );
 
     electronMenuItems = di.inject(electronMenuItemsInjectable);

src/main/protocol-handler/lens-protocol-router-main/lens-protocol-router-main.injectable.ts

@@ -18,23 +18,17 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
 import extensionLoaderInjectable from "../../../extensions/extension-loader/extension-loader.injectable";
-import type { Dependencies } from "./lens-protocol-router-main";
 import { LensProtocolRouterMain } from "./lens-protocol-router-main";
 
-const lensProtocolRouterMainInjectable: Injectable<
+const lensProtocolRouterMainInjectable = getInjectable({
-  LensProtocolRouterMain,
+  instantiate: (di) =>
-  Dependencies
+    new LensProtocolRouterMain({
-> = {
-  getDependencies: di => ({
       extensionLoader: di.inject(extensionLoaderInjectable),
     }),
 
-  instantiate: dependencies => new LensProtocolRouterMain(dependencies),
-
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default lensProtocolRouterMainInjectable;

src/renderer/components/+extensions/attempt-install-by-info/attempt-install-by-info.injectable.ts

@@ -18,20 +18,19 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
+import { attemptInstallByInfo } from "./attempt-install-by-info";
-import { attemptInstallByInfo, ExtensionInfo } from "./attempt-install-by-info";
 import attemptInstallInjectable from "../attempt-install/attempt-install.injectable";
 import getBaseRegistryUrlInjectable from "../get-base-registry-url/get-base-registry-url.injectable";
 
-const attemptInstallByInfoInjectable: Injectable<(extensionInfo: ExtensionInfo) => Promise<void>, {}> = {
+const attemptInstallByInfoInjectable = getInjectable({
-  getDependencies: di => ({
+  instantiate: (di) =>
+    attemptInstallByInfo({
       attemptInstall: di.inject(attemptInstallInjectable),
       getBaseRegistryUrl: di.inject(getBaseRegistryUrlInjectable),
     }),
 
-  instantiate: attemptInstallByInfo,
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default attemptInstallByInfoInjectable;

src/renderer/components/+extensions/attempt-install/attempt-install.injectable.ts

@@ -18,29 +18,21 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
-
-import type { ExtendableDisposer } from "../../../../common/utils";
 import extensionLoaderInjectable from "../../../../extensions/extension-loader/extension-loader.injectable";
 import uninstallExtensionInjectable from "../uninstall-extension/uninstall-extension.injectable";
-import type { Dependencies } from "./attempt-install";
 import { attemptInstall } from "./attempt-install";
-import type { InstallRequest } from "./install-request";
 import unpackExtensionInjectable from "./unpack-extension/unpack-extension.injectable";
 
-const attemptInstallInjectable: Injectable<
+const attemptInstallInjectable = getInjectable({
-  (request: InstallRequest, d?: ExtendableDisposer) => Promise<void>,
+  instantiate: (di) =>
-  Dependencies
+    attemptInstall({
-> = {
-  getDependencies: di => ({
       extensionLoader: di.inject(extensionLoaderInjectable),
       uninstallExtension: di.inject(uninstallExtensionInjectable),
       unpackExtension: di.inject(unpackExtensionInjectable),
     }),
 
-  instantiate: attemptInstall,
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default attemptInstallInjectable;

src/renderer/components/+extensions/attempt-install/unpack-extension/unpack-extension.injectable.tsx

@@ -18,26 +18,18 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { lifecycleEnum } from "@ogre-tools/injectable";
-import { Dependencies, unpackExtension } from "./unpack-extension";
+import { unpackExtension } from "./unpack-extension";
-import type { InstallRequestValidated } from "../create-temp-files-and-validate/create-temp-files-and-validate";
-import type { Disposer } from "../../../../../common/utils";
 import extensionLoaderInjectable from "../../../../../extensions/extension-loader/extension-loader.injectable";
 
-const unpackExtensionInjectable: Injectable<
+const unpackExtensionInjectable = getInjectable({
-  (
+  instantiate: (di) =>
-    request: InstallRequestValidated,
+    unpackExtension({
-    disposeDownloading?: Disposer,
-  ) => Promise<void>,
-  Dependencies
-> = {
-  getDependencies: di => ({
       extensionLoader: di.inject(extensionLoaderInjectable),
     }),
 
-  instantiate: unpackExtension,
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default unpackExtensionInjectable;

src/renderer/components/+extensions/attempt-installs/attempt-installs.injectable.ts

@@ -18,21 +18,17 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
+import { attemptInstalls } from "./attempt-installs";
-import { attemptInstalls, Dependencies } from "./attempt-installs";
 import attemptInstallInjectable from "../attempt-install/attempt-install.injectable";
 
-const attemptInstallsInjectable: Injectable<
+const attemptInstallsInjectable = getInjectable({
-  (filePaths: string[]) => Promise<void>,
+  instantiate: (di) =>
-  Dependencies
+    attemptInstalls({
-> = {
-  getDependencies: di => ({
       attemptInstall: di.inject(attemptInstallInjectable),
     }),
 
-  instantiate: attemptInstalls,
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default attemptInstallsInjectable;

src/renderer/components/+extensions/confirm-uninstall-extension/confirm-uninstall-extension.injectable.ts

@@ -18,25 +18,17 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
+import { confirmUninstallExtension } from "./confirm-uninstall-extension";
-import {
-  confirmUninstallExtension,
-  Dependencies,
-} from "./confirm-uninstall-extension";
-import type { InstalledExtension } from "../../../../extensions/extension-discovery";
 import uninstallExtensionInjectable from "../uninstall-extension/uninstall-extension.injectable";
 
-const confirmUninstallExtensionInjectable: Injectable<
+const confirmUninstallExtensionInjectable = getInjectable({
-  (extension: InstalledExtension) => Promise<void>,
+  instantiate: (di) =>
-  Dependencies
+    confirmUninstallExtension({
-> = {
-  getDependencies: di => ({
       uninstallExtension: di.inject(uninstallExtensionInjectable),
     }),
 
-  instantiate: confirmUninstallExtension,
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default confirmUninstallExtensionInjectable;

src/renderer/components/+extensions/confirm-uninstall-extension/confirm-uninstall-extension.tsx

@@ -25,7 +25,7 @@ import { extensionDisplayName } from "../../../../extensions/lens-extension";
 import { ConfirmDialog } from "../../confirm-dialog";
 
 export interface Dependencies {
-  uninstallExtension: (id: LensExtensionId) => Promise<void>;
+  uninstallExtension: (id: LensExtensionId) => Promise<boolean>;
 }
 
 export const confirmUninstallExtension =

src/renderer/components/+extensions/disable-extension/disable-extension.injectable.ts

@@ -18,23 +18,17 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
 import extensionLoaderInjectable from "../../../../extensions/extension-loader/extension-loader.injectable";
-import type { LensExtensionId } from "../../../../extensions/lens-extension";
+import { disableExtension } from "./disable-extension";
-import { Dependencies, disableExtension } from "./disable-extension";
 
-const disableExtensionInjectable: Injectable<
+const disableExtensionInjectable = getInjectable({
-  (id: LensExtensionId) => void,
+  instantiate: (di) =>
-  Dependencies
+    disableExtension({
-> = {
-  getDependencies: di => ({
       extensionLoader: di.inject(extensionLoaderInjectable),
     }),
 
-  instantiate: disableExtension,
-
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default disableExtensionInjectable;

src/renderer/components/+extensions/enable-extension/enable-extension.injectable.ts

@@ -18,23 +18,17 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
 import extensionLoaderInjectable from "../../../../extensions/extension-loader/extension-loader.injectable";
-import type { LensExtensionId } from "../../../../extensions/lens-extension";
+import { enableExtension } from "./enable-extension";
-import { Dependencies, enableExtension } from "./enable-extension";
 
-const enableExtensionInjectable: Injectable<
+const enableExtensionInjectable = getInjectable({
-  (id: LensExtensionId) => void,
+  instantiate: (di) =>
-  Dependencies
+    enableExtension({
-> = {
-  getDependencies: di => ({
       extensionLoader: di.inject(extensionLoaderInjectable),
     }),
 
-  instantiate: enableExtension,
-
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default enableExtensionInjectable;

src/renderer/components/+extensions/get-base-registry-url/get-base-registry-url.injectable.ts

@@ -19,18 +19,20 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-import { Injectable, lifecycleEnum } from "@ogre-tools/injectable";
+import {
+  getInjectable,
+  lifecycleEnum,
+} from "@ogre-tools/injectable";
 import { UserStore } from "../../../../common/user-store";
-import { Dependencies, getBaseRegistryUrl } from "./get-base-registry-url";
+import { getBaseRegistryUrl } from "./get-base-registry-url";
 
-const getBaseRegistryUrlInjectable: Injectable<() => Promise<string>, Dependencies> = {
+const getBaseRegistryUrlInjectable = getInjectable({
-  getDependencies: () => ({
+  instantiate: () => getBaseRegistryUrl({
     // TODO: use injection
     getRegistryUrlPreference: () => UserStore.getInstance().extensionRegistryUrl,
   }),
   
-  instantiate: getBaseRegistryUrl,
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default getBaseRegistryUrlInjectable;

src/renderer/components/+extensions/install-from-input/install-from-input.injectable.ts

@@ -18,25 +18,19 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
 import attemptInstallInjectable from "../attempt-install/attempt-install.injectable";
-import type { Dependencies } from "./install-from-input";
 import { installFromInput } from "./install-from-input";
-import attemptInstallByInfoInjectable
+import attemptInstallByInfoInjectable from "../attempt-install-by-info/attempt-install-by-info.injectable";
-  from "../attempt-install-by-info/attempt-install-by-info.injectable";
 
-const installFromInputInjectable: Injectable<
+const installFromInputInjectable = getInjectable({
-  (input: string) => Promise<void>,
+  instantiate: (di) =>
-  Dependencies
+    installFromInput({
-> = {
-  getDependencies: di => ({
       attemptInstall: di.inject(attemptInstallInjectable),
       attemptInstallByInfo: di.inject(attemptInstallByInfoInjectable),
     }),
 
-  instantiate: installFromInput,
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default installFromInputInjectable;

src/renderer/components/+extensions/install-from-select-file-dialog/install-from-select-file-dialog.injectable.ts

@@ -18,18 +18,17 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
+import { installFromSelectFileDialog } from "./install-from-select-file-dialog";
-import { Dependencies, installFromSelectFileDialog } from "./install-from-select-file-dialog";
 import attemptInstallsInjectable from "../attempt-installs/attempt-installs.injectable";
 
-const installFromSelectFileDialogInjectable: Injectable<() => Promise<void>, Dependencies> = {
+const installFromSelectFileDialogInjectable = getInjectable({
-  getDependencies: di => ({
+  instantiate: (di) =>
+    installFromSelectFileDialog({
       attemptInstalls: di.inject(attemptInstallsInjectable),
     }),
 
-  instantiate: installFromSelectFileDialog,
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default installFromSelectFileDialogInjectable;

src/renderer/components/+extensions/install-on-drop/install-on-drop.injectable.ts

@@ -18,21 +18,17 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
+import { installOnDrop } from "./install-on-drop";
-import { Dependencies, installOnDrop } from "./install-on-drop";
 import attemptInstallsInjectable from "../attempt-installs/attempt-installs.injectable";
 
-const installOnDropInjectable: Injectable<
+const installOnDropInjectable = getInjectable({
-  (files: File[]) => Promise<void>,
+  instantiate: (di) =>
-  Dependencies
+    installOnDrop({
-> = {
-  getDependencies: di => ({
       attemptInstalls: di.inject(attemptInstallsInjectable),
     }),
 
-  instantiate: installOnDrop,
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default installOnDropInjectable;

src/renderer/components/+extensions/uninstall-extension/uninstall-extension.injectable.ts

@@ -18,23 +18,17 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
+import extensionLoaderInjectable from "../../../../extensions/extension-loader/extension-loader.injectable";
-import type { LensExtensionId } from "../../../../extensions/lens-extension";
+import { uninstallExtension } from "./uninstall-extension";
-import extensionLoaderInjectable
-  from "../../../../extensions/extension-loader/extension-loader.injectable";
-import { Dependencies, uninstallExtension } from "./uninstall-extension";
 
-const uninstallExtensionInjectable: Injectable<
+const uninstallExtensionInjectable = getInjectable({
-  (extensionId: LensExtensionId) => Promise<boolean>,
+  instantiate: (di) =>
-  Dependencies
+    uninstallExtension({
-> = {
-  getDependencies: di => ({
       extensionLoader: di.inject(extensionLoaderInjectable),
     }),
 
-  instantiate: uninstallExtension,
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default uninstallExtensionInjectable;

src/renderer/components/+extensions/user-extensions/user-extensions.injectable.ts

@@ -18,24 +18,18 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import { Injectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { computed, IComputedValue } from "mobx";
+import { computed } from "mobx";
-import type { InstalledExtension } from "../../../../extensions/extension-discovery";
-import type { ExtensionLoader } from "../../../../extensions/extension-loader";
 import extensionLoaderInjectable from "../../../../extensions/extension-loader/extension-loader.injectable";
 
-const userExtensionsInjectable: Injectable<
+const userExtensionsInjectable = getInjectable({
-  IComputedValue<InstalledExtension[]>,
-  { extensionLoader: ExtensionLoader }
-> = {
-  getDependencies: di => ({
-    extensionLoader: di.inject(extensionLoaderInjectable),
-  }),
-
   lifecycle: lifecycleEnum.singleton,
 
-  instantiate: ({ extensionLoader }) =>
+  instantiate: (di) => {
-    computed(() => [...extensionLoader.userExtensions.values()]),
+    const extensionLoader = di.inject(extensionLoaderInjectable);
-};
+
+    return computed(() => [...extensionLoader.userExtensions.values()]);
+  },
+});
 
 export default userExtensionsInjectable;

src/renderer/components/kube-object-menu/dependencies/api-manager.injectable.ts

@@ -18,15 +18,12 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { ApiManager } from "../../../../common/k8s-api/api-manager";
 import { apiManager } from "../../../../common/k8s-api/api-manager";
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
 
-const apiManagerInjectable: Injectable<ApiManager> = {
+const apiManagerInjectable = getInjectable({
-  getDependencies: () => ({}),
   instantiate: () => apiManager,
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default apiManagerInjectable;

src/renderer/components/kube-object-menu/dependencies/cluster-name.injectable.ts

@@ -19,23 +19,17 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
-import type { Cluster } from "../../../../main/cluster";
 import clusterInjectable from "./cluster.injectable";
 
-interface Dependencies {
+const clusterNameInjectable = getInjectable({
-  cluster: Cluster;
+  instantiate: (di) => {
-}
+    const cluster = di.inject(clusterInjectable);
 
-const clusterNameInjectable: Injectable<string | undefined, Dependencies> = {
+    return cluster?.name;
-  getDependencies: di => ({
+  },
-    cluster: di.inject(clusterInjectable),
-  }),
-
-  instantiate: ({ cluster }) => cluster?.name,
 
   lifecycle: lifecycleEnum.transient,
-};
+});
 
 export default clusterNameInjectable;

src/renderer/components/kube-object-menu/dependencies/cluster.injectable.ts

@@ -20,14 +20,11 @@
  */
 import { getActiveClusterEntity } from "../../../api/catalog-entity-registry";
 
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
-import type { Cluster } from "../../../../main/cluster";
 
-const clusterInjectable: Injectable<Cluster | null> = {
+const clusterInjectable = getInjectable({
-  getDependencies: () => ({}),
   instantiate: () => getActiveClusterEntity(),
   lifecycle: lifecycleEnum.transient,
-};
+});
 
 export default clusterInjectable;

src/renderer/components/kube-object-menu/dependencies/edit-resource-tab.injectable.ts

@@ -19,13 +19,11 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 import { editResourceTab } from "../../dock/edit-resource.store";
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
 
-const editResourceTabInjectable: Injectable<typeof editResourceTab> = {
+const editResourceTabInjectable = getInjectable({
-  getDependencies: () => ({}),
   instantiate: () => editResourceTab,
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default editResourceTabInjectable;

src/renderer/components/kube-object-menu/dependencies/hide-details.injectable.ts

@@ -19,13 +19,11 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 import { hideDetails } from "../../kube-detail-params";
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
 
-export const hideDetailsInjectable: Injectable<typeof hideDetails> = {
+export const hideDetailsInjectable = getInjectable({
-  getDependencies: () => ({}),
   instantiate: () => hideDetails,
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default hideDetailsInjectable;

src/renderer/components/kube-object-menu/dependencies/kube-object-menu-items/get-kube-object-menu-items.ts

@@ -21,23 +21,18 @@
 import type { KubeObjectMenuRegistry } from "../../../../../extensions/registries";
 import type { KubeObject } from "../../../../../common/k8s-api/kube-object";
 
-export interface Dependencies {
+export const getKubeObjectMenuItems = ({
+  kubeObjectMenuRegistry,
+  kubeObject,
+}: {
   kubeObjectMenuRegistry: KubeObjectMenuRegistry;
-}
-
-export interface InstantiationParameter {
   kubeObject: KubeObject;
-}
+}) => {
-
-export const getKubeObjectMenuItems = (
-  { kubeObjectMenuRegistry }: Dependencies,
-  { kubeObject }: InstantiationParameter,
-) => {
   if (!kubeObject) {
     return [];
   }
 
   return kubeObjectMenuRegistry
     .getItemsForKind(kubeObject.kind, kubeObject.apiVersion)
-    .map(item => item.components.MenuItem);
+    .map((item) => item.components.MenuItem);
 };

src/renderer/components/kube-object-menu/dependencies/kube-object-menu-items/kube-object-menu-items.injectable.ts

@@ -18,27 +18,20 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import { Injectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
 import kubeObjectMenuRegistryInjectable from "./kube-object-menu-registry.injectable";
 
-import {
+import { getKubeObjectMenuItems } from "./get-kube-object-menu-items";
-  InstantiationParameter,
+import type { KubeObject } from "../../../../../common/k8s-api/kube-object";
-  Dependencies,
-  getKubeObjectMenuItems,
-} from "./get-kube-object-menu-items";
 
-const kubeObjectMenuItemsInjectable: Injectable<
+const kubeObjectMenuItemsInjectable = getInjectable({
-  ReturnType<typeof getKubeObjectMenuItems>,
+  instantiate: (di, { kubeObject }: { kubeObject: KubeObject }) =>
-  Dependencies,
+    getKubeObjectMenuItems({
-  InstantiationParameter
-> = {
-  getDependencies: di => ({
       kubeObjectMenuRegistry: di.inject(kubeObjectMenuRegistryInjectable),
+      kubeObject,
     }),
 
-  instantiate: getKubeObjectMenuItems,
-
   lifecycle: lifecycleEnum.transient,
-};
+});
 
 export default kubeObjectMenuItemsInjectable;

src/renderer/components/kube-object-menu/dependencies/kube-object-menu-items/kube-object-menu-registry.injectable.ts

@@ -19,13 +19,11 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 import { KubeObjectMenuRegistry } from "../../../../../extensions/registries";
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
 
-const kubeObjectMenuRegistryInjectable: Injectable<KubeObjectMenuRegistry> = {
+const kubeObjectMenuRegistryInjectable = getInjectable({
-  getDependencies: () => ({}),
   instantiate: () => KubeObjectMenuRegistry.getInstance(),
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default kubeObjectMenuRegistryInjectable;

src/renderer/components/kube-object-menu/kube-object-menu.test.tsx

@@ -55,18 +55,18 @@ describe("kube-object-menu", () => {
 
     render = renderFor(di);
 
-    di.override(clusterInjectable, {
+    di.override(clusterInjectable, () => ({
       name: "Some name",
-    } as Cluster);
+    }) as Cluster);
 
-    di.override(apiManagerInjectable, {
+    di.override(apiManagerInjectable, () => ({
       // eslint-disable-next-line unused-imports/no-unused-vars-ts
       getStore: api => undefined,
-    } as ApiManager);
+    }) as ApiManager);
 
-    di.override(hideDetailsInjectable, () => {});
+    di.override(hideDetailsInjectable, () => () => {});
 
-    di.override(editResourceTabInjectable, () => ({
+    di.override(editResourceTabInjectable, () => () => ({
       id: "irrelevant",
       kind: TabKind.TERMINAL,
       pinned: false,
@@ -93,7 +93,7 @@ describe("kube-object-menu", () => {
   });
 
   it("given no cluster, does not crash", () => {
-    di.override(clusterInjectable, null);
+    di.override(clusterInjectable, () => null);
 
     expect(() => {
       render(<KubeObjectMenu object={null} toolbar={true} />);
@@ -110,7 +110,7 @@ describe("kube-object-menu", () => {
 
   describe("given kube object", () => {
     let baseElement: Element;
-    let removeActionMock: AsyncFnMock<Function>;
+    let removeActionMock: AsyncFnMock<() => void>;
 
     beforeEach(async () => {
       const objectStub = KubeObject.create({

src/renderer/protocol-handler/bind-protocol-add-route-handlers/bind-protocol-add-route-handlers.injectable.ts

@@ -18,24 +18,18 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
 import attemptInstallByInfoInjectable from "../../components/+extensions/attempt-install-by-info/attempt-install-by-info.injectable";
-import {
+import { bindProtocolAddRouteHandlers } from "./bind-protocol-add-route-handlers";
-  bindProtocolAddRouteHandlers,
+import lensProtocolRouterRendererInjectable from "../lens-protocol-router-renderer/lens-protocol-router-renderer.injectable";
-  Dependencies,
-} from "./bind-protocol-add-route-handlers";
-import lensProtocolRouterRendererInjectable
-  from "../lens-protocol-router-renderer/lens-protocol-router-renderer.injectable";
 
-const bindProtocolAddRouteHandlersInjectable: Injectable<() => void, Dependencies> = {
+const bindProtocolAddRouteHandlersInjectable = getInjectable({
-  getDependencies: di => ({
+  instantiate: di=> bindProtocolAddRouteHandlers({
     attemptInstallByInfo: di.inject(attemptInstallByInfoInjectable),
     lensProtocolRouterRenderer: di.inject(lensProtocolRouterRendererInjectable),
   }),
 
-  instantiate: bindProtocolAddRouteHandlers,
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default bindProtocolAddRouteHandlersInjectable;

src/renderer/protocol-handler/lens-protocol-router-renderer/lens-protocol-router-renderer.injectable.ts

@@ -18,23 +18,17 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import { lifecycleEnum } from "@ogre-tools/injectable";
 import extensionLoaderInjectable from "../../../extensions/extension-loader/extension-loader.injectable";
-import type { Dependencies } from "./lens-protocol-router-renderer";
 import { LensProtocolRouterRenderer } from "./lens-protocol-router-renderer";
 
-const lensProtocolRouterRendererInjectable: Injectable<
+const lensProtocolRouterRendererInjectable = getInjectable({
-  LensProtocolRouterRenderer,
+  instantiate: (di) =>
-  Dependencies
+    new LensProtocolRouterRenderer({
-> = {
-  getDependencies: di => ({
       extensionLoader: di.inject(extensionLoaderInjectable),
     }),
 
-  instantiate: dependencies => new LensProtocolRouterRenderer(dependencies),
-
   lifecycle: lifecycleEnum.singleton,
-};
+});
 
 export default lensProtocolRouterRendererInjectable;