Skip to content

Commit 9a82604

Browse files
committed
fix(desktop): close the window before quit cleanup
1 parent 5304f3e commit 9a82604

2 files changed

Lines changed: 175 additions & 77 deletions

File tree

Lines changed: 145 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
import { assert, describe, it } from "@effect/vitest";
2+
import * as Deferred from "effect/Deferred";
23
import * as Effect from "effect/Effect";
34
import * as Layer from "effect/Layer";
45
import * as Ref from "effect/Ref";
@@ -7,90 +8,105 @@ import type * as Electron from "electron";
78

89
import * as ElectronApp from "../electron/ElectronApp.ts";
910
import * as ElectronTheme from "../electron/ElectronTheme.ts";
11+
import * as ElectronWindow from "../electron/ElectronWindow.ts";
1012
import * as DesktopEnvironment from "./DesktopEnvironment.ts";
1113
import * as DesktopLifecycle from "./DesktopLifecycle.ts";
1214
import * as DesktopShutdown from "./DesktopShutdown.ts";
1315
import * as DesktopState from "./DesktopState.ts";
1416
import * as DesktopWindow from "../window/DesktopWindow.ts";
1517

18+
function makeElectronAppLayer(
19+
appListeners: Map<string, (...args: readonly unknown[]) => void>,
20+
quit: Effect.Effect<void> = Effect.void,
21+
) {
22+
const registerListener = (eventName: string, listener: (...args: readonly unknown[]) => void) =>
23+
Effect.acquireRelease(
24+
Effect.sync(() => {
25+
appListeners.set(eventName, listener);
26+
}),
27+
() =>
28+
Effect.sync(() => {
29+
appListeners.delete(eventName);
30+
}),
31+
).pipe(Effect.asVoid);
32+
33+
return Layer.succeed(ElectronApp.ElectronApp, {
34+
metadata: Effect.die("unexpected metadata read"),
35+
name: Effect.succeed("T3 Code"),
36+
whenReady: Effect.void,
37+
quit,
38+
exit: () => Effect.void,
39+
relaunch: () => Effect.void,
40+
setPath: () => Effect.void,
41+
setName: () => Effect.void,
42+
setAboutPanelOptions: () => Effect.void,
43+
setAppUserModelId: () => Effect.void,
44+
getAppMetrics: Effect.succeed([]),
45+
isDefaultProtocolClient: () => Effect.succeed(false),
46+
setAsDefaultProtocolClient: () => Effect.succeed(true),
47+
setDesktopName: () => Effect.void,
48+
setDockIcon: () => Effect.void,
49+
appendCommandLineSwitch: () => Effect.void,
50+
removeCommandLineSwitch: () => Effect.void,
51+
onBeforeQuitForUpdate: (listener) => registerListener("before-quit-for-update", listener),
52+
on: (eventName, listener) =>
53+
registerListener(eventName, listener as unknown as (...args: readonly unknown[]) => void),
54+
} satisfies ElectronApp.ElectronApp["Service"]);
55+
}
56+
57+
const electronThemeLayer = Layer.succeed(ElectronTheme.ElectronTheme, {
58+
shouldUseDarkColors: Effect.succeed(false),
59+
setSource: () => Effect.void,
60+
onUpdated: () => Effect.void,
61+
});
62+
63+
function makeElectronWindowLayer(destroyAll: Effect.Effect<void> = Effect.void) {
64+
return Layer.succeed(ElectronWindow.ElectronWindow, {
65+
create: () => Effect.die("unexpected window creation"),
66+
main: Effect.die("unexpected main window read"),
67+
currentMainOrFirst: Effect.die("unexpected current window read"),
68+
focusedMainOrFirst: Effect.die("unexpected focused window read"),
69+
setMain: () => Effect.void,
70+
clearMain: () => Effect.void,
71+
reveal: () => Effect.void,
72+
sendAll: () => Effect.void,
73+
destroyAll,
74+
syncAllAppearance: () => Effect.void,
75+
});
76+
}
77+
78+
function makeDesktopWindowLayer(flushMainWindowBounds: Effect.Effect<void> = Effect.void) {
79+
return Layer.succeed(DesktopWindow.DesktopWindow, {
80+
createMain: Effect.die("unexpected window creation"),
81+
ensureMain: Effect.die("unexpected window creation"),
82+
revealOrCreateMain: Effect.die("unexpected window creation"),
83+
activate: Effect.void,
84+
createMainIfBackendReady: Effect.void,
85+
showConnectingSplash: Effect.void,
86+
handleBackendReady: () => Effect.void,
87+
handleBackendNotReady: Effect.void,
88+
flushMainWindowBounds,
89+
dispatchMenuAction: () => Effect.void,
90+
zoomMain: () => Effect.void,
91+
syncAppearance: Effect.void,
92+
});
93+
}
94+
1695
describe("DesktopLifecycle", () => {
1796
for (const platform of ["darwin", "win32", "linux"] satisfies ReadonlyArray<NodeJS.Platform>) {
1897
it.effect(`lets the updater's quit event proceed on ${platform}`, () => {
1998
const appListeners = new Map<string, (...args: readonly unknown[]) => void>();
2099

21-
const electronAppLayer = Layer.succeed(ElectronApp.ElectronApp, {
22-
metadata: Effect.die("unexpected metadata read"),
23-
name: Effect.succeed("T3 Code"),
24-
whenReady: Effect.void,
25-
quit: Effect.void,
26-
exit: () => Effect.void,
27-
relaunch: () => Effect.void,
28-
setPath: () => Effect.void,
29-
setName: () => Effect.void,
30-
setAboutPanelOptions: () => Effect.void,
31-
setAppUserModelId: () => Effect.void,
32-
getAppMetrics: Effect.succeed([]),
33-
isDefaultProtocolClient: () => Effect.succeed(false),
34-
setAsDefaultProtocolClient: () => Effect.succeed(true),
35-
setDesktopName: () => Effect.void,
36-
setDockIcon: () => Effect.void,
37-
appendCommandLineSwitch: () => Effect.void,
38-
removeCommandLineSwitch: () => Effect.void,
39-
onBeforeQuitForUpdate: (listener) =>
40-
Effect.acquireRelease(
41-
Effect.sync(() => {
42-
appListeners.set("before-quit-for-update", listener);
43-
}),
44-
() =>
45-
Effect.sync(() => {
46-
appListeners.delete("before-quit-for-update");
47-
}),
48-
).pipe(Effect.asVoid),
49-
on: (eventName, listener) =>
50-
Effect.acquireRelease(
51-
Effect.sync(() => {
52-
appListeners.set(
53-
eventName,
54-
listener as unknown as (...args: readonly unknown[]) => void,
55-
);
56-
}),
57-
() =>
58-
Effect.sync(() => {
59-
appListeners.delete(eventName);
60-
}),
61-
).pipe(Effect.asVoid),
62-
} satisfies ElectronApp.ElectronApp["Service"]);
63-
64-
const electronThemeLayer = Layer.succeed(ElectronTheme.ElectronTheme, {
65-
shouldUseDarkColors: Effect.succeed(false),
66-
setSource: () => Effect.void,
67-
onUpdated: () => Effect.void,
68-
});
69-
70-
const desktopWindowLayer = Layer.succeed(DesktopWindow.DesktopWindow, {
71-
createMain: Effect.die("unexpected window creation"),
72-
ensureMain: Effect.die("unexpected window creation"),
73-
revealOrCreateMain: Effect.die("unexpected window creation"),
74-
activate: Effect.void,
75-
createMainIfBackendReady: Effect.void,
76-
showConnectingSplash: Effect.void,
77-
handleBackendReady: () => Effect.void,
78-
handleBackendNotReady: Effect.void,
79-
flushMainWindowBounds: Effect.void,
80-
dispatchMenuAction: () => Effect.void,
81-
zoomMain: () => Effect.void,
82-
syncAppearance: Effect.void,
83-
});
84-
85100
const environmentLayer = Layer.succeed(DesktopEnvironment.DesktopEnvironment, {
86101
platform,
87102
isDevelopment: false,
88103
} as DesktopEnvironment.DesktopEnvironment["Service"]);
89104

90105
const layer = DesktopLifecycle.layer.pipe(
91-
Layer.provideMerge(electronAppLayer),
106+
Layer.provideMerge(makeElectronAppLayer(appListeners)),
92107
Layer.provideMerge(electronThemeLayer),
93-
Layer.provideMerge(desktopWindowLayer),
108+
Layer.provideMerge(makeElectronWindowLayer()),
109+
Layer.provideMerge(makeDesktopWindowLayer()),
94110
Layer.provideMerge(environmentLayer),
95111
Layer.provideMerge(DesktopShutdown.layer),
96112
Layer.provideMerge(DesktopState.layer),
@@ -122,4 +138,67 @@ describe("DesktopLifecycle", () => {
122138
).pipe(Effect.provide(layer));
123139
});
124140
}
141+
142+
it.effect("destroys windows before waiting for backend shutdown", () =>
143+
Effect.gen(function* () {
144+
const appListeners = new Map<string, (...args: readonly unknown[]) => void>();
145+
const shutdownRequested = yield* Deferred.make<void>();
146+
const allowShutdown = yield* Deferred.make<void>();
147+
const quitRequested = yield* Deferred.make<void>();
148+
const events: string[] = [];
149+
150+
const quit = Effect.sync(() => {
151+
events.push("quit");
152+
}).pipe(Effect.andThen(Deferred.succeed(quitRequested, undefined)), Effect.asVoid);
153+
const destroyAll = Effect.sync(() => {
154+
events.push("destroy");
155+
});
156+
const flushMainWindowBounds = Effect.sync(() => {
157+
events.push("flush");
158+
});
159+
160+
const desktopShutdownLayer = Layer.succeed(DesktopShutdown.DesktopShutdown, {
161+
request: Effect.sync(() => {
162+
events.push("request");
163+
}).pipe(Effect.andThen(Deferred.succeed(shutdownRequested, undefined)), Effect.asVoid),
164+
awaitRequest: Deferred.await(shutdownRequested),
165+
markComplete: Deferred.succeed(allowShutdown, undefined).pipe(Effect.asVoid),
166+
awaitComplete: Deferred.await(allowShutdown),
167+
isComplete: Deferred.isDone(allowShutdown),
168+
});
169+
170+
const environmentLayer = Layer.succeed(DesktopEnvironment.DesktopEnvironment, {
171+
platform: "darwin",
172+
isDevelopment: false,
173+
} as DesktopEnvironment.DesktopEnvironment["Service"]);
174+
175+
const layer = DesktopLifecycle.layer.pipe(
176+
Layer.provideMerge(makeElectronAppLayer(appListeners, quit)),
177+
Layer.provideMerge(electronThemeLayer),
178+
Layer.provideMerge(makeElectronWindowLayer(destroyAll)),
179+
Layer.provideMerge(makeDesktopWindowLayer(flushMainWindowBounds)),
180+
Layer.provideMerge(environmentLayer),
181+
Layer.provideMerge(desktopShutdownLayer),
182+
Layer.provideMerge(DesktopState.layer),
183+
);
184+
185+
yield* Effect.scoped(
186+
Effect.gen(function* () {
187+
const lifecycle = yield* DesktopLifecycle.DesktopLifecycle;
188+
yield* lifecycle.register;
189+
190+
const event = { preventDefault: () => undefined } as Electron.Event;
191+
appListeners.get("before-quit")?.(event);
192+
193+
yield* Deferred.await(shutdownRequested);
194+
const eventsBeforeCleanup = [...events];
195+
yield* Deferred.succeed(allowShutdown, undefined);
196+
yield* Deferred.await(quitRequested);
197+
198+
assert.deepEqual(eventsBeforeCleanup, ["flush", "destroy", "request"]);
199+
assert.deepEqual(events, ["flush", "destroy", "request", "quit"]);
200+
}),
201+
).pipe(Effect.provide(layer));
202+
}),
203+
);
125204
});

‎apps/desktop/src/app/DesktopLifecycle.ts‎

Lines changed: 30 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@ import { makeComponentLogger } from "./DesktopObservability.ts";
1212
import * as DesktopShutdown from "./DesktopShutdown.ts";
1313
import * as ElectronApp from "../electron/ElectronApp.ts";
1414
import * as ElectronTheme from "../electron/ElectronTheme.ts";
15+
import * as ElectronWindow from "../electron/ElectronWindow.ts";
1516
import * as DesktopState from "./DesktopState.ts";
1617
import * as DesktopWindow from "../window/DesktopWindow.ts";
1718

@@ -35,16 +36,24 @@ export type DesktopLifecycleRuntimeServices =
3536
| ElectronApp.ElectronApp
3637
| ElectronTheme.ElectronTheme;
3738

39+
type DesktopLifecycleRegistrationServices =
40+
| DesktopLifecycleRuntimeServices
41+
| ElectronWindow.ElectronWindow;
42+
3843
/**
39-
* @effect-expect-leaking DesktopEnvironment | DesktopShutdown | DesktopState | DesktopWindow | ElectronApp | ElectronTheme
44+
* @effect-expect-leaking DesktopEnvironment | DesktopShutdown | DesktopState | DesktopWindow | ElectronApp | ElectronTheme | ElectronWindow
4045
*/
4146
export class DesktopLifecycle extends Context.Service<
4247
DesktopLifecycle,
4348
{
4449
readonly relaunch: (
4550
reason: string,
4651
) => Effect.Effect<void, never, DesktopLifecycleRuntimeServices>;
47-
readonly register: Effect.Effect<void, never, Scope.Scope | DesktopLifecycleRuntimeServices>;
52+
readonly register: Effect.Effect<
53+
void,
54+
never,
55+
Scope.Scope | DesktopLifecycleRegistrationServices
56+
>;
4857
}
4958
>()("@t3tools/desktop/app/DesktopLifecycle") {}
5059

@@ -73,22 +82,23 @@ function addScopedListener<Args extends ReadonlyArray<unknown>>(
7382
}
7483

7584
const requestDesktopShutdownAndWait = Effect.fn("desktop.lifecycle.requestShutdownAndWait")(
76-
function* (): Effect.fn.Return<
77-
void,
78-
never,
79-
DesktopShutdown.DesktopShutdown | DesktopWindow.DesktopWindow
80-
> {
85+
function* (
86+
afterBoundsFlush: Effect.Effect<void> = Effect.void,
87+
): Effect.fn.Return<void, never, DesktopShutdown.DesktopShutdown | DesktopWindow.DesktopWindow> {
8188
const shutdown = yield* DesktopShutdown.DesktopShutdown;
8289
const desktopWindow = yield* DesktopWindow.DesktopWindow;
8390
yield* desktopWindow.flushMainWindowBounds;
91+
yield* afterBoundsFlush;
8492
yield* shutdown.request;
8593
yield* shutdown.awaitComplete;
8694
},
8795
);
8896

8997
function handleBeforeQuit(
9098
event: Electron.Event,
91-
runEffect: <A, E>(effect: Effect.Effect<A, E, DesktopLifecycleRuntimeServices>) => Promise<A>,
99+
runEffect: <A, E>(
100+
effect: Effect.Effect<A, E, DesktopLifecycleRegistrationServices>,
101+
) => Promise<A>,
92102
allowQuit: () => boolean,
93103
markQuitAllowed: () => void,
94104
): void {
@@ -107,9 +117,16 @@ function handleBeforeQuit(
107117
void runEffect(
108118
Effect.gen(function* () {
109119
const state = yield* DesktopState.DesktopState;
120+
const electronWindow = yield* ElectronWindow.ElectronWindow;
110121
yield* Ref.set(state.quitting, true);
111122
yield* logLifecycleInfo("before-quit received");
112-
yield* requestDesktopShutdownAndWait();
123+
yield* requestDesktopShutdownAndWait(
124+
electronWindow.destroyAll.pipe(
125+
Effect.catchCause((cause) =>
126+
logLifecycleError("failed to destroy windows before shutdown", { cause }),
127+
),
128+
),
129+
);
113130
}).pipe(Effect.withSpan("desktop.lifecycle.beforeQuit")),
114131
).finally(() => {
115132
markQuitAllowed();
@@ -124,7 +141,9 @@ function handleBeforeQuit(
124141

125142
function quitFromSignal(
126143
signal: "SIGINT" | "SIGTERM",
127-
runEffect: <A, E>(effect: Effect.Effect<A, E, DesktopLifecycleRuntimeServices>) => Promise<A>,
144+
runEffect: <A, E>(
145+
effect: Effect.Effect<A, E, DesktopLifecycleRegistrationServices>,
146+
) => Promise<A>,
128147
): void {
129148
void runEffect(
130149
Effect.gen(function* () {
@@ -173,7 +192,7 @@ export const make = DesktopLifecycle.of({
173192
const electronApp = yield* ElectronApp.ElectronApp;
174193
const electronTheme = yield* ElectronTheme.ElectronTheme;
175194
const environment = yield* DesktopEnvironment.DesktopEnvironment;
176-
const context = yield* Effect.context<DesktopLifecycleRuntimeServices>();
195+
const context = yield* Effect.context<DesktopLifecycleRegistrationServices>();
177196
const runEffect = Effect.runPromiseWith(context);
178197
let quitAllowed = false;
179198
let updaterQuitAllowed = false;

0 commit comments

Comments
 (0)