hendrik/lens
1
0
Fork 0
mirror of https://github.com/lensapp/lens.git synced 2025-05-20 05:10:56 +00:00
Code Issues Projects Releases Wiki Activity

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

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

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>
This commit is contained in:
Iku-turso 2022-04-11 11:11:41 +03:00 committed by Janne Savolainen
parent abee24ce8b
commit e991b22781
No known key found for this signature in database
GPG Key ID: 8C6CFB2FFFE8F68A
10 changed files with 114 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
src/main/start-main-application/before-application-is-ready/implementations/setup-closing-of-application.injectable.ts Normal file
View File

@ -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;

35
src/main/start-main-application/before-application-is-ready/implementations/setup-main-window-visibility.injectable.ts Normal file
View File

@ -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;

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

@ -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;

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

@ -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",
});

43
src/main/start-main-application/on-application-is-ready/implementations/setup-deep-linking.injectable.ts Normal file
View File

@ -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;

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

@ -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;

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

@ -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",
});

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

@ -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;

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

@ -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",
});

50
src/main/start-main-application/start-main-application.injectable.ts
View File

@ -2,20 +2,12 @@
* 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 { 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 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 runMany(beforeApplicationIsReadyInjectionToken)();
await app.whenReady();
await runManyAfterApplicationIsReady();
await runMany(onApplicationIsReadyInjectionToken)();
};
},
});