1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97

// SPDX-FileCopyrightText: 2024 Shota FUJI <pockawoooh@gmail.com>
// SPDX-License-Identifier: AGPL-3.0-only

import { isValidMessage, type Message } from "@/worker/message.ts";

type BackendResult<T, E> =
	| {
			ok: true;
			data: T;
	  }
	| {
			ok: false;
			error: E;
	  };

export function loadWorker(
	onLoaded: (worker: BackendResult<Worker, string>) => void,
): void {
	const worker = new Worker(new URL("./worker/main.ts", import.meta.url), {
		type: "module",
	});

	const eventListener = (event: ErrorEvent | MessageEvent) => {
		worker.removeEventListener("error", eventListener);
		worker.removeEventListener("message", eventListener);

		if (event instanceof ErrorEvent) {
			onLoaded({
				ok: false,
				error: String(event.error),
			});
			return;
		}

		if (event.data !== "ready") {
			onLoaded({
				ok: false,
				error: `Unexpected initial message received: ${event.data}`,
			});
			return;
		}

		onLoaded({
			ok: true,
			data: worker,
		});
	};

	worker.addEventListener("error", eventListener);
	worker.addEventListener("message", eventListener);
}

export function request(
	worker: Worker,
	service: string,
	method: string,
	request: Uint8Array,
	onResponse: (response: Uint8Array) => void,
): void {
	const requestID = crypto.randomUUID();

	const handler = (event: MessageEvent) => {
		if (!isValidMessage(event.data) || event.data.id !== requestID) {
			return;
		}

		worker.removeEventListener("message", handler);

		if (import.meta.env.NODE_ENV === "development" && event.data.service !== service) {
			console.warn(
				`Worker backend returned mismatching service: sent=${service}, received=${event.data.service}`,
			);
		}

		if (import.meta.env.NODE_ENV === "development" && event.data.method !== method) {
			console.warn(
				`Worker backend returned mismatching service: sent=${method}, received=${event.data.method}`,
			);
		}

		onResponse(event.data.data);
	};

	worker.addEventListener("message", handler);

	worker.postMessage(
		{
			id: requestID,
			service,
			method,
			data: request,
		} satisfies Message,
		{
			transfer: [request.buffer],
		},
	);
}