Extract implementation for intent over technical phenomena (here electron events)

Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

src/main/start-main-application/before-application-is-ready/implementations/setup-closing-of-application.injectable.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import electronAppInjectable from "../../../app-paths/get-electron-app-path/electron-app/electron-app.injectable";
+import { beforeApplicationIsReadyInjectionToken } from "../before-application-is-ready-injection-token";
+import { onApplicationCloseInjectionToken } from "../../on-application-close/on-application-close-injection-token";
+import { runManyFor } from "../../run-many-for";
+
+const setupClosingOfApplicationInjectable = getInjectable({
+  id: "setup-closing-of-application",
+
+  instantiate: (di) => {
+    const app = di.inject(electronAppInjectable);
+
+    const runManyForApplicationClose = runManyFor(di)(
+      onApplicationCloseInjectionToken,
+    );
+
+    return {
+      run: () => {
+        app.on("will-quit", async (event) => {
+          await runManyForApplicationClose({ event });
+        });
+      },
+    };
+  },
+
+  injectionToken: beforeApplicationIsReadyInjectionToken,
+});
+
+export default setupClosingOfApplicationInjectable;

src/main/start-main-application/before-application-is-ready/implementations/setup-main-window-visibility.injectable.ts

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import loggerInjectable from "../../../../common/logger.injectable";
+import windowManagerInjectable from "../../../window-manager.injectable";
+import electronAppInjectable from "../../../app-paths/get-electron-app-path/electron-app/electron-app.injectable";
+import { beforeApplicationIsReadyInjectionToken } from "../before-application-is-ready-injection-token";
+
+const setupMainWindowVisibilityInjectable = getInjectable({
+  id: "setup-main-window-visibility",
+
+  instantiate: (di) => {
+    const logger = di.inject(loggerInjectable);
+    const windowManager = di.inject(windowManagerInjectable);
+    const app = di.inject(electronAppInjectable);
+
+    return {
+      run: () => {
+        app.on("activate", async (_, hasVisibleWindows) => {
+          logger.info("APP:ACTIVATE", { hasVisibleWindows });
+
+          if (!hasVisibleWindows) {
+            await windowManager.ensureMainWindow(false);
+          }
+        });
+      },
+    };
+  },
+
+  injectionToken: beforeApplicationIsReadyInjectionToken,
+});
+
+export default setupMainWindowVisibilityInjectable;

src/main/start-main-application/on-application-activation/implementations/ensure-visible-main-window.injectable.ts

@@ -1,31 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import loggerInjectable from "../../../../common/logger.injectable";
-import windowManagerInjectable from "../../../window-manager.injectable";
-import { onApplicationActivationInjectionToken } from "../on-application-activation-injection-token";
-
-const ensureVisibleMainWindowInjectable = getInjectable({
-  id: "ensure-visible-main-window",
-
-  instantiate: (di) => {
-    const logger = di.inject(loggerInjectable);
-    const windowManager = di.inject(windowManagerInjectable);
-
-    return {
-      run: ({ hasVisibleWindows }) => {
-        logger.info("APP:ACTIVATE", { hasVisibleWindows });
-
-        if (!hasVisibleWindows) {
-          windowManager.ensureMainWindow(false);
-        }
-      },
-    };
-  },
-
-  injectionToken: onApplicationActivationInjectionToken,
-});
-
-export default ensureVisibleMainWindowInjectable;

src/main/start-main-application/on-application-activation/on-application-activation-injection-token.ts

@@ -1,12 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { Runnable } from "../run-many-for";
-
-export const onApplicationActivationInjectionToken = getInjectionToken<
-  Runnable<{ hasVisibleWindows: boolean }>
->({
-  id: "on-application-activation",
-});

src/main/start-main-application/on-application-is-ready/implementations/setup-deep-linking.injectable.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import lensProtocolRouterMainInjectable from "../../../protocol-handler/lens-protocol-router-main/lens-protocol-router-main.injectable";
+import windowManagerInjectable from "../../../window-manager.injectable";
+import { onApplicationIsReadyInjectionToken } from "../on-application-is-ready-injection-token";
+import electronAppInjectable from "../../../app-paths/get-electron-app-path/electron-app/electron-app.injectable";
+
+const setupDeepLinking = getInjectable({
+  id: "setup-deep-linking",
+
+  instantiate: (di) => {
+    const lensProtocolRouterMain = di.inject(lensProtocolRouterMainInjectable);
+    const windowManager = di.inject(windowManagerInjectable);
+    const app = di.inject(electronAppInjectable);
+
+    return {
+      run: () => {
+        app.on("open-url", async (event, url) => {
+          event.preventDefault();
+
+          await lensProtocolRouterMain.route(url);
+        });
+
+        app.on("second-instance", async (_, commandLineArguments) => {
+          for (const arg of commandLineArguments) {
+            if (arg.toLowerCase().startsWith("lens://")) {
+              await lensProtocolRouterMain.route(arg);
+            }
+          }
+
+          await windowManager.ensureMainWindow();
+        });
+      },
+    };
+  },
+
+  injectionToken: onApplicationIsReadyInjectionToken,
+});
+
+export default setupDeepLinking;

src/main/start-main-application/on-open-of-url/implementations/open-url-using-protocol-router.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import lensProtocolRouterMainInjectable from "../../../protocol-handler/lens-protocol-router-main/lens-protocol-router-main.injectable";
-import { onOpenOfUrlInjectionToken } from "../on-open-of-url-injection-token";
-
-const openUrlUsingProtocolRouterInjectable = getInjectable({
-  id: "open-url-using-protocol-router",
-
-  instantiate: (di) => {
-    const lensProtocolRouterMain = di.inject(lensProtocolRouterMainInjectable);
-
-    return {
-      run: ({ event, url }) => {
-        event.preventDefault();
-
-        lensProtocolRouterMain.route(url);
-      },
-    };
-  },
-
-  injectionToken: onOpenOfUrlInjectionToken,
-});
-
-export default openUrlUsingProtocolRouterInjectable;

src/main/start-main-application/on-open-of-url/on-open-of-url-injection-token.ts

@@ -1,16 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { Runnable } from "../run-many-for";
-import type { Event } from "electron";
-
-export const onOpenOfUrlInjectionToken = getInjectionToken<
-  Runnable<{
-    event: Event;
-    url: string;
-  }>
->({
-  id: "on-open-of-url",
-});

src/main/start-main-application/on-second-application-instance/implementations/setup-protocol-router-for-second-instance.injectable.ts

@@ -1,37 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import loggerInjectable from "../../../../common/logger.injectable";
-import lensProtocolRouterMainInjectable from "../../../protocol-handler/lens-protocol-router-main/lens-protocol-router-main.injectable";
-import windowManagerInjectable from "../../../window-manager.injectable";
-import { onSecondApplicationInstanceInjectionToken } from "../on-second-application-instance-injection-token";
-
-const setupProtocolRouterForSecondInstanceInjectable = getInjectable({
-  id: "setup-protocol-router-for-second-instance",
-
-  instantiate: (di) => {
-    const logger = di.inject(loggerInjectable);
-    const lensProtocolRouterMain = di.inject(lensProtocolRouterMainInjectable);
-    const windowManager = di.inject(windowManagerInjectable);
-
-    return {
-      run: async ({ commandLineArguments }) => {
-        logger.debug("second-instance message");
-
-        for (const arg of commandLineArguments) {
-          if (arg.toLowerCase().startsWith("lens://")) {
-            lensProtocolRouterMain.route(arg);
-          }
-        }
-
-        await windowManager.ensureMainWindow();
-      },
-    };
-  },
-
-  injectionToken: onSecondApplicationInstanceInjectionToken,
-});
-
-export default setupProtocolRouterForSecondInstanceInjectable;

src/main/start-main-application/on-second-application-instance/on-second-application-instance-injection-token.ts

@@ -1,12 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { Runnable } from "../run-many-for";
-
-export const onSecondApplicationInstanceInjectionToken = getInjectionToken<
-  Runnable<{ commandLineArguments: string[] }>
->({
-  id: "on-second-application-instance",
-});

src/main/start-main-application/start-main-application.injectable.ts

@@ -2,20 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import {
+import { getInjectable } from "@ogre-tools/injectable";
-  getInjectable,
-} from "@ogre-tools/injectable";
 
 import electronAppInjectable from "../app-paths/get-electron-app-path/electron-app/electron-app.injectable";
 import { beforeApplicationIsReadyInjectionToken } from "./before-application-is-ready/before-application-is-ready-injection-token";
 import { onApplicationIsReadyInjectionToken } from "./on-application-is-ready/on-application-is-ready-injection-token";
-import { onSecondApplicationInstanceInjectionToken } from "./on-second-application-instance/on-second-application-instance-injection-token";
-import { onApplicationActivationInjectionToken } from "./on-application-activation/on-application-activation-injection-token";
-import { onOpenOfUrlInjectionToken } from "./on-open-of-url/on-open-of-url-injection-token";
 import { runManyFor } from "./run-many-for";
-import {
-  onApplicationCloseInjectionToken,
-} from "./on-application-close/on-application-close-injection-token";
 
 const startMainApplicationInjectable = getInjectable({
   id: "start-main-application",
@@ -24,48 +16,12 @@ const startMainApplicationInjectable = getInjectable({
     const runMany = runManyFor(di);
     const app = di.inject(electronAppInjectable);
 
-    const runManyBeforeApplicationIsReady = runMany(
-      beforeApplicationIsReadyInjectionToken,
-    );
-
-    const runManyAfterApplicationIsReady = runMany(
-      onApplicationIsReadyInjectionToken,
-    );
-
-    const runManyForSecondApplicationInstance = runMany(
-      onSecondApplicationInstanceInjectionToken,
-    );
-
-    const runManyForApplicationActivation = runMany(
-      onApplicationActivationInjectionToken,
-    );
-
-    const runManyForApplicationClose = runMany(onApplicationCloseInjectionToken);
-
-    const runManyForOpenOfUrl = runMany(onOpenOfUrlInjectionToken);
-
     return async () => {
-      app.on("second-instance", async (_, commandLineArguments) => {
+      await runMany(beforeApplicationIsReadyInjectionToken)();
-        await runManyForSecondApplicationInstance({ commandLineArguments });
-      });
-
-      app.on("activate", async (_, hasVisibleWindows) => {
-        await runManyForApplicationActivation({ hasVisibleWindows });
-      });
-
-      app.on("will-quit", async (event) => {
-        await runManyForApplicationClose({ event });
-      });
-
-      app.on("open-url", async (event, url) => {
-        await runManyForOpenOfUrl({ event, url });
-      });
-
-      await runManyBeforeApplicationIsReady();
 
       await app.whenReady();
 
-      await runManyAfterApplicationIsReady();
+      await runMany(onApplicationIsReadyInjectionToken)();
     };
   },
 });