Simplify logic for injecting many instances which can reactively change e.g. based on extension being enabled or disabled (#5662)

* Reorganize stuff to prevent circular dependencies

Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>

* Install injectable extension to allow injecting reactively many implementations

Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>

* Switch to using computedInjectMany over filtering injectMany based on enabled extensions for simplicity

Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>

* Remove await for not being needed

Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>

* Sort dependencies alphabetically

Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>

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

@@ -5,10 +5,11 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import { ExtensionLoader } from "./extension-loader";
 import updateExtensionsStateInjectable from "./update-extensions-state/update-extensions-state.injectable";
-import { extensionRegistratorInjectionToken } from "./extension-registrator-injection-token";
 import extensionInstallationCounterInjectable from "./extension-installation-counter.injectable";
 import { createExtensionInstanceInjectionToken } from "./create-extension-instance.token";
 import extensionInstancesInjectable from "./extension-instances.injectable";
+import type { LensExtension } from "../lens-extension";
+import extensionInjectable from "./extension/extension.injectable";
 
 const extensionLoaderInjectable = getInjectable({
   id: "extension-loader",
@@ -16,9 +17,9 @@ const extensionLoaderInjectable = getInjectable({
   instantiate: (di) => new ExtensionLoader({
     updateExtensionsState: di.inject(updateExtensionsStateInjectable),
     createExtensionInstance: di.inject(createExtensionInstanceInjectionToken),
-    extensionRegistrators: di.injectMany(extensionRegistratorInjectionToken),
     extensionInstallationCounter: di.inject(extensionInstallationCounterInjectable),
     extensionInstances: di.inject(extensionInstancesInjectable),
+    getExtension: (instance: LensExtension) => di.inject(extensionInjectable, instance),
   }),
 });
 

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

@@ -23,15 +23,16 @@ import { requestExtensionLoaderInitialState } from "../../renderer/ipc";
 import assert from "assert";
 import { EventEmitter } from "../../common/event-emitter";
 import type { CreateExtensionInstance } from "./create-extension-instance.token";
+import type { Extension } from "./extension/extension.injectable";
 
 const logModule = "[EXTENSIONS-LOADER]";
 
 interface Dependencies {
   updateExtensionsState: (extensionsState: Record<LensExtensionId, LensExtensionState>) => void;
   createExtensionInstance: CreateExtensionInstance;
-  readonly extensionRegistrators: ((extension: LensExtension, extensionInstallationCount: number) => void)[];
   readonly extensionInstallationCounter: Map<string, number>;
   readonly extensionInstances: ObservableMap<LensExtensionId, LensExtension>;
+  getExtension: (instance: LensExtension) => Extension;
 }
 
 export interface ExtensionLoading {
@@ -169,6 +170,11 @@ export class ExtensionLoader {
 
     try {
       instance.disable();
+
+      const registeredExtension = this.dependencies.getExtension(instance);
+
+      registeredExtension.deregister();
+
       this.onRemoveExtensionId.emit(instance.id);
       this.dependencies.extensionInstances.delete(lensExtensionId);
       this.nonInstancesByName.delete(instance.name);
@@ -354,13 +360,9 @@ export class ExtensionLoader {
     );
 
     extensions.forEach(({ instance }) => {
-      const installationCount = (this.dependencies.extensionInstallationCounter.get(instance.sanitizedExtensionId) ?? 0) + 1;
+      const getExtension = this.dependencies.getExtension(instance);
 
-      this.dependencies.extensionInstallationCounter.set(instance.sanitizedExtensionId, installationCount);
-
-      this.dependencies.extensionRegistrators.forEach((register) =>
-        register(instance, installationCount),
-      );
+      getExtension.register();
     });
 
     // Return ExtensionLoading[]

src/extensions/extension-loader/extension-registrator-injection-token.ts

@@ -2,11 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
+import type { Injectable } from "@ogre-tools/injectable";
 import { getInjectionToken } from "@ogre-tools/injectable";
 import type { LensExtension } from "../lens-extension";
 
 export const extensionRegistratorInjectionToken = getInjectionToken<
-  (extension: LensExtension, extensionInstallationCount: number) => void
+  (extension: LensExtension) => Injectable<any, any, any>[]
     >({
       id: "extension-registrator-token",
     });

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

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import type { LensExtension } from "../../lens-extension";
+import { extensionRegistratorInjectionToken } from "../extension-registrator-injection-token";
+
+export interface Extension {
+  register: () => void;
+  deregister: () => void;
+}
+
+const extensionInjectable = getInjectable({
+  id: "extension",
+
+  instantiate: (parentDi, instance: LensExtension): Extension => {
+    const extensionInjectable = getInjectable({
+      id: `extension-${instance.sanitizedExtensionId}`,
+
+      instantiate: (childDi) => {
+        const extensionRegistrators = childDi.injectMany(extensionRegistratorInjectionToken);
+
+        return {
+          register: () => {
+            const injectables = extensionRegistrators.flatMap((getInjectablesOfExtension) =>
+              getInjectablesOfExtension(instance),
+            );
+
+            childDi.register(...injectables);
+          },
+
+          deregister: () => {
+            parentDi.deregister(extensionInjectable);
+          },
+        };
+      },
+    });
+
+    parentDi.register(extensionInjectable);
+
+    return parentDi.inject(extensionInjectable);
+  },
+
+  lifecycle: lifecycleEnum.keyedSingleton({
+    getInstanceKey: (di, extension: LensExtension) => extension,
+  }),
+});
+
+export default extensionInjectable;