emr-bridge 2.0.1 → 2.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +8 -0
- package/cjs/entries/index.d.ts +1 -0
- package/cjs/entries/index.js +19 -0
- package/cjs/errors.d.ts +18 -0
- package/cjs/errors.js +34 -1
- package/cjs/package.json +3 -0
- package/cjs/scripts/base-bridge.d.ts +15 -8
- package/cjs/scripts/base-bridge.js +88 -42
- package/cjs/scripts/helpers/entities-info.d.ts +20 -0
- package/cjs/scripts/helpers/entities-info.js +38 -0
- package/cjs/scripts/helpers/env.js +1 -1
- package/cjs/scripts/helpers/id.d.ts +9 -0
- package/cjs/scripts/helpers/id.js +15 -1
- package/cjs/scripts/helpers/index.d.ts +3 -0
- package/cjs/scripts/helpers/index.js +7 -1
- package/cjs/scripts/helpers/ipc-channel.d.ts +10 -0
- package/cjs/scripts/helpers/ipc-channel.js +73 -61
- package/cjs/scripts/helpers/ipc-event-in-main.d.ts +7 -1
- package/cjs/scripts/helpers/ipc-event-in-main.js +27 -2
- package/cjs/scripts/helpers/ipc-payload.d.ts +38 -0
- package/cjs/scripts/helpers/ipc-payload.js +82 -0
- package/cjs/scripts/helpers/ipc-result.d.ts +9 -1
- package/cjs/scripts/helpers/ipc-result.js +32 -9
- package/cjs/scripts/helpers/names.d.ts +20 -0
- package/cjs/scripts/helpers/names.js +77 -0
- package/cjs/scripts/helpers/transfer.d.ts +8 -0
- package/cjs/scripts/helpers/transfer.js +24 -10
- package/cjs/scripts/helpers/web-contents-events-container.d.ts +57 -8
- package/cjs/scripts/helpers/web-contents-events-container.js +150 -25
- package/cjs/scripts/main/publish.d.ts +2 -2
- package/cjs/scripts/main/publish.js +177 -78
- package/cjs/scripts/preload/bridge.d.ts +2 -2
- package/cjs/scripts/preload/bridge.js +7 -6
- package/cjs/scripts/preload/provider.js +113 -18
- package/cjs/scripts/renderer/bridge.js +5 -0
- package/cjs/scripts/renderer/tunnels.d.ts +19 -2
- package/cjs/scripts/renderer/tunnels.js +133 -32
- package/cjs/types.d.ts +4 -0
- package/esm/entries/index.d.ts +1 -0
- package/esm/entries/index.js +5 -1
- package/esm/errors.d.ts +18 -0
- package/esm/errors.js +30 -0
- package/esm/scripts/base-bridge.d.ts +15 -8
- package/esm/scripts/base-bridge.js +90 -44
- package/esm/scripts/helpers/entities-info.d.ts +20 -0
- package/esm/scripts/helpers/entities-info.js +35 -0
- package/esm/scripts/helpers/env.js +1 -1
- package/esm/scripts/helpers/id.d.ts +9 -0
- package/esm/scripts/helpers/id.js +15 -1
- package/esm/scripts/helpers/index.d.ts +3 -0
- package/esm/scripts/helpers/index.js +3 -0
- package/esm/scripts/helpers/ipc-channel.d.ts +10 -0
- package/esm/scripts/helpers/ipc-channel.js +74 -63
- package/esm/scripts/helpers/ipc-event-in-main.d.ts +7 -1
- package/esm/scripts/helpers/ipc-event-in-main.js +24 -2
- package/esm/scripts/helpers/ipc-payload.d.ts +38 -0
- package/esm/scripts/helpers/ipc-payload.js +79 -0
- package/esm/scripts/helpers/ipc-result.d.ts +9 -1
- package/esm/scripts/helpers/ipc-result.js +32 -9
- package/esm/scripts/helpers/names.d.ts +20 -0
- package/esm/scripts/helpers/names.js +74 -0
- package/esm/scripts/helpers/transfer.d.ts +8 -0
- package/esm/scripts/helpers/transfer.js +24 -10
- package/esm/scripts/helpers/web-contents-events-container.d.ts +57 -8
- package/esm/scripts/helpers/web-contents-events-container.js +150 -25
- package/esm/scripts/main/publish.d.ts +2 -2
- package/esm/scripts/main/publish.js +179 -80
- package/esm/scripts/preload/bridge.d.ts +2 -2
- package/esm/scripts/preload/bridge.js +8 -7
- package/esm/scripts/preload/provider.js +114 -19
- package/esm/scripts/renderer/bridge.js +5 -0
- package/esm/scripts/renderer/tunnels.d.ts +19 -2
- package/esm/scripts/renderer/tunnels.js +135 -35
- package/esm/types.d.ts +4 -0
- package/package.json +35 -13
|
@@ -12,7 +12,7 @@ export declare function emitEvent<T = unknown>(name: string, value?: T): void;
|
|
|
12
12
|
* @param receives - Принимаемые классы, недоступные для транспортировки по умолчанию. _Порядок важен._
|
|
13
13
|
* @returns Функция отписки от события.
|
|
14
14
|
*/
|
|
15
|
-
export declare function on<TValue = any>(name: string, listener: EventListener<TValue>, receives?: HasSnapshotClass<
|
|
15
|
+
export declare function on<TValue = any>(name: string, listener: EventListener<TValue>, receives?: HasSnapshotClass<any>): EventUnsubscribe;
|
|
16
16
|
/**
|
|
17
17
|
* Добавить одноразовый обработчик renderer события.
|
|
18
18
|
* @param name - Имя события.
|
|
@@ -20,7 +20,7 @@ export declare function on<TValue = any>(name: string, listener: EventListener<T
|
|
|
20
20
|
* @param receives - Класс передаваемого значения, если оно не может быть передано стандартным способом.
|
|
21
21
|
* @returns Функция отписки от события.
|
|
22
22
|
*/
|
|
23
|
-
export declare function once<TValue = any>(name: string, listener: EventListener<TValue>, receives?: HasSnapshotClass<
|
|
23
|
+
export declare function once<TValue = any>(name: string, listener: EventListener<TValue>, receives?: HasSnapshotClass<any>): EventUnsubscribe;
|
|
24
24
|
/**
|
|
25
25
|
* Опубликовать (сделать доступной) функцию из main процесса.
|
|
26
26
|
* @param name - Имя, по которому будет доступна функция в renderer процессе.
|
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
// Методы публикации в main процессе.
|
|
2
2
|
import { ipcMain } from 'electron';
|
|
3
|
-
import { PublishMethodsUnavailableError } from '../../errors.js';
|
|
4
|
-
import { Env, Errors, IpcChannel, IpcEventInMain, IpcResult, Transfer, WebContentsEventsContainer } from '../helpers/index.js';
|
|
3
|
+
import { NoGetAccessError, PublishMethodsUnavailableError, TrySetReadonlyError } from '../../errors.js';
|
|
4
|
+
import { Env, Errors, IpcChannel, IpcEventInMain, IpcPayload, IpcResult, Names, Transfer, WebContentsEventsContainer } from '../helpers/index.js';
|
|
5
5
|
/**
|
|
6
6
|
* Информация о сущностях.
|
|
7
7
|
*/
|
|
@@ -19,10 +19,62 @@ const eventsContainer = new WebContentsEventsContainer();
|
|
|
19
19
|
const canThrowError = (Env.hasWindow || !ipcMain)
|
|
20
20
|
? Errors.getThrower(PublishMethodsUnavailableError)
|
|
21
21
|
: () => { };
|
|
22
|
+
/**
|
|
23
|
+
* Безопасно отправить результат в канал `renderer` процесса.
|
|
24
|
+
* @param sender - Получатель.
|
|
25
|
+
* @param channel - IPC канал.
|
|
26
|
+
* @param result - Результат.
|
|
27
|
+
*/
|
|
28
|
+
function sendToRenderer(sender, channel, result) {
|
|
29
|
+
if (!sender || sender.isDestroyed()) {
|
|
30
|
+
return;
|
|
31
|
+
}
|
|
32
|
+
try {
|
|
33
|
+
sender.send(channel, result);
|
|
34
|
+
}
|
|
35
|
+
catch {
|
|
36
|
+
// Получатель мог быть уничтожен между проверкой и отправкой.
|
|
37
|
+
}
|
|
38
|
+
}
|
|
39
|
+
/**
|
|
40
|
+
* Создать результат со значением, не выбрасывая исключение наружу.
|
|
41
|
+
* @param value - Значение.
|
|
42
|
+
* @param id - Уникальный идентификатор.
|
|
43
|
+
*/
|
|
44
|
+
function createValueResult(value, id) {
|
|
45
|
+
try {
|
|
46
|
+
return IpcResult.createWithValue(value, id);
|
|
47
|
+
}
|
|
48
|
+
catch (error) {
|
|
49
|
+
return IpcResult.createWithError(error, id);
|
|
50
|
+
}
|
|
51
|
+
}
|
|
22
52
|
if (ipcMain) {
|
|
23
53
|
ipcMain.on(IpcChannel.publicInfo.get(), event => new IpcEventInMain(event).return(entitiesInfo));
|
|
24
|
-
ipcMain.on(IpcChannel.event.on(), (event,
|
|
25
|
-
|
|
54
|
+
ipcMain.on(IpcChannel.event.on(), (event, payload) => {
|
|
55
|
+
const name = IpcPayload.eventName(payload);
|
|
56
|
+
if (name) {
|
|
57
|
+
eventsContainer.addOn(name, event.sender);
|
|
58
|
+
}
|
|
59
|
+
});
|
|
60
|
+
ipcMain.on(IpcChannel.event.once(), (event, payload) => {
|
|
61
|
+
const name = IpcPayload.eventName(payload);
|
|
62
|
+
if (name) {
|
|
63
|
+
eventsContainer.addOnce(name, event.sender);
|
|
64
|
+
}
|
|
65
|
+
});
|
|
66
|
+
ipcMain.on(IpcChannel.event.off(), (event, payload) => {
|
|
67
|
+
const name = IpcPayload.eventName(payload);
|
|
68
|
+
if (!name) {
|
|
69
|
+
return;
|
|
70
|
+
}
|
|
71
|
+
if (IpcPayload.eventType(payload) === 'once') {
|
|
72
|
+
eventsContainer.removeOnce(name, event.sender);
|
|
73
|
+
}
|
|
74
|
+
else {
|
|
75
|
+
eventsContainer.removeOn(name, event.sender);
|
|
76
|
+
}
|
|
77
|
+
});
|
|
26
78
|
}
|
|
27
79
|
/**
|
|
28
80
|
* Вызвать событие из main процесса.
|
|
@@ -31,31 +83,27 @@ if (ipcMain) {
|
|
|
31
83
|
*/
|
|
32
84
|
export function emitEvent(name, value) {
|
|
33
85
|
canThrowError();
|
|
86
|
+
Names.validateEvent(name);
|
|
34
87
|
const emitChannel = IpcChannel.event.emit(name);
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
eventsContainer.clearOnce(name);
|
|
43
|
-
})
|
|
44
|
-
.catch(reason => {
|
|
45
|
-
eventsContainer.getAll(name).forEach(sender => sender.send(emitChannel, IpcResult.createWithError(reason)));
|
|
46
|
-
eventsContainer.clearOnce(name);
|
|
47
|
-
});
|
|
48
|
-
return;
|
|
88
|
+
// Подписчики фиксируются на момент вызова: слушатель, добавленный
|
|
89
|
+
// после `emitEvent`, не должен получить уже отправленное событие.
|
|
90
|
+
const senders = eventsContainer.getAll(name);
|
|
91
|
+
eventsContainer.clearOnce(name);
|
|
92
|
+
const deliver = (result) => {
|
|
93
|
+
for (const sender of senders) {
|
|
94
|
+
sendToRenderer(sender, emitChannel, result);
|
|
49
95
|
}
|
|
50
|
-
|
|
51
|
-
|
|
96
|
+
};
|
|
97
|
+
if (Transfer.isPromiseLike(value)) {
|
|
98
|
+
try {
|
|
99
|
+
value.then(result => deliver(createValueResult(result)), reason => deliver(IpcResult.createWithError(reason)));
|
|
52
100
|
}
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
eventsContainer.clearOnce(name);
|
|
101
|
+
catch (error) {
|
|
102
|
+
deliver(IpcResult.createWithError(error));
|
|
103
|
+
}
|
|
104
|
+
return;
|
|
58
105
|
}
|
|
106
|
+
deliver(createValueResult(value));
|
|
59
107
|
}
|
|
60
108
|
/**
|
|
61
109
|
* Добавить обработчик renderer события.
|
|
@@ -66,17 +114,8 @@ export function emitEvent(name, value) {
|
|
|
66
114
|
*/
|
|
67
115
|
export function on(name, listener, receives) {
|
|
68
116
|
canThrowError();
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
if (Transfer.isSnapshotValue(value) && receives) {
|
|
72
|
-
listener(Transfer.getFromSnapshot(value, receives));
|
|
73
|
-
}
|
|
74
|
-
else {
|
|
75
|
-
listener(value);
|
|
76
|
-
}
|
|
77
|
-
};
|
|
78
|
-
ipcMain.on(emitChannel, handler);
|
|
79
|
-
return () => ipcMain.removeListener(emitChannel, handler);
|
|
117
|
+
Names.validateEvent(name);
|
|
118
|
+
return subscribeEvent(name, listener, receives, false);
|
|
80
119
|
}
|
|
81
120
|
/**
|
|
82
121
|
* Добавить одноразовый обработчик renderer события.
|
|
@@ -87,16 +126,50 @@ export function on(name, listener, receives) {
|
|
|
87
126
|
*/
|
|
88
127
|
export function once(name, listener, receives) {
|
|
89
128
|
canThrowError();
|
|
129
|
+
Names.validateEvent(name);
|
|
130
|
+
return subscribeEvent(name, listener, receives, true);
|
|
131
|
+
}
|
|
132
|
+
/**
|
|
133
|
+
* Подписаться на событие из `renderer` процесса.
|
|
134
|
+
* @param name - Имя события.
|
|
135
|
+
* @param listener - Обработчик.
|
|
136
|
+
* @param receives - Класс передаваемого значения.
|
|
137
|
+
* @param isOnce - Одноразовая подписка.
|
|
138
|
+
* @returns Функция отписки от события.
|
|
139
|
+
*/
|
|
140
|
+
function subscribeEvent(name, listener, receives, isOnce) {
|
|
141
|
+
if (typeof listener !== 'function') {
|
|
142
|
+
throw new TypeError('Обработчик события должен быть функцией.');
|
|
143
|
+
}
|
|
90
144
|
const emitChannel = IpcChannel.event.emit(name);
|
|
91
|
-
const handler = (_,
|
|
92
|
-
|
|
93
|
-
|
|
145
|
+
const handler = (_, payload) => {
|
|
146
|
+
const result = IpcPayload.result(payload);
|
|
147
|
+
if (!result) {
|
|
148
|
+
return;
|
|
94
149
|
}
|
|
95
|
-
|
|
96
|
-
|
|
150
|
+
if (result.error) {
|
|
151
|
+
console.error(`[emr-bridge] Ошибка события '${name}':\n${result.error}`);
|
|
152
|
+
return;
|
|
153
|
+
}
|
|
154
|
+
let value = result.value;
|
|
155
|
+
if (Transfer.isSnapshotValue(result.value) && receives) {
|
|
156
|
+
try {
|
|
157
|
+
value = Transfer.getFromSnapshot(result.value, receives);
|
|
158
|
+
}
|
|
159
|
+
catch (error) {
|
|
160
|
+
// Недоверенный снимок из renderer не должен ронять main процесс.
|
|
161
|
+
console.error(`[emr-bridge] Не удалось восстановить значение события '${name}'.`, error);
|
|
162
|
+
return;
|
|
163
|
+
}
|
|
97
164
|
}
|
|
165
|
+
listener(value);
|
|
98
166
|
};
|
|
99
|
-
|
|
167
|
+
if (isOnce) {
|
|
168
|
+
ipcMain.once(emitChannel, handler);
|
|
169
|
+
}
|
|
170
|
+
else {
|
|
171
|
+
ipcMain.on(emitChannel, handler);
|
|
172
|
+
}
|
|
100
173
|
return () => ipcMain.removeListener(emitChannel, handler);
|
|
101
174
|
}
|
|
102
175
|
/**
|
|
@@ -107,30 +180,40 @@ export function once(name, listener, receives) {
|
|
|
107
180
|
*/
|
|
108
181
|
export function publishFunction(name, func, receives = []) {
|
|
109
182
|
canThrowError();
|
|
183
|
+
Names.validateEntity(name);
|
|
184
|
+
if (typeof func !== 'function') {
|
|
185
|
+
throw new TypeError(`Публикуемая функция '${name}' должна быть функцией.`);
|
|
186
|
+
}
|
|
187
|
+
if (!Array.isArray(receives)) {
|
|
188
|
+
throw new TypeError('`receives` должен быть массивом классов.');
|
|
189
|
+
}
|
|
110
190
|
const channel = IpcChannel.func.call(name);
|
|
111
191
|
entitiesInfo.functions.add(name);
|
|
112
192
|
ipcMain.removeAllListeners(channel);
|
|
113
|
-
ipcMain.on(channel, (e,
|
|
193
|
+
ipcMain.on(channel, (e, payload) => {
|
|
114
194
|
const event = new IpcEventInMain(e);
|
|
195
|
+
const request = IpcPayload.request(payload);
|
|
196
|
+
if (!request) {
|
|
197
|
+
event.return(IpcResult.createWithError(new TypeError('Некорректный запрос вызова функции.')));
|
|
198
|
+
return;
|
|
199
|
+
}
|
|
115
200
|
const receivesCopy = [...receives];
|
|
116
201
|
try {
|
|
117
|
-
const preparedArgs = args.map(arg => (Transfer.isSnapshotValue(arg) && receivesCopy[0]
|
|
202
|
+
const preparedArgs = request.args.map(arg => (Transfer.isSnapshotValue(arg) && receivesCopy[0]
|
|
118
203
|
? Transfer.getFromSnapshot(arg, receivesCopy.shift())
|
|
119
204
|
: arg));
|
|
120
205
|
const result = func(...preparedArgs);
|
|
121
|
-
if (result
|
|
206
|
+
if (Transfer.isPromiseLike(result)) {
|
|
122
207
|
const promiseChannel = IpcChannel.promise.get(channel);
|
|
123
|
-
result
|
|
124
|
-
.then(value => event.send(promiseChannel, IpcResult.createWithValue(value, id)))
|
|
125
|
-
.catch(reason => event.send(promiseChannel, IpcResult.createWithError(reason, id)));
|
|
208
|
+
result.then(value => event.send(promiseChannel, createValueResult(value, request.id)), reason => event.send(promiseChannel, IpcResult.createWithError(reason, request.id)));
|
|
126
209
|
event.return(IpcResult.createWithPromise(promiseChannel));
|
|
127
210
|
}
|
|
128
211
|
else {
|
|
129
|
-
event.return(
|
|
212
|
+
event.return(createValueResult(result, request.id));
|
|
130
213
|
}
|
|
131
214
|
}
|
|
132
215
|
catch (error) {
|
|
133
|
-
event.return(IpcResult.createWithError(error));
|
|
216
|
+
event.return(IpcResult.createWithError(error, request.id));
|
|
134
217
|
}
|
|
135
218
|
});
|
|
136
219
|
}
|
|
@@ -141,37 +224,53 @@ export function publishFunction(name, func, receives = []) {
|
|
|
141
224
|
*/
|
|
142
225
|
export function publishVariable(name, descriptor) {
|
|
143
226
|
canThrowError();
|
|
227
|
+
Names.validateEntity(name);
|
|
228
|
+
if (!descriptor || typeof descriptor !== 'object') {
|
|
229
|
+
throw new TypeError(`Не задан дескриптор переменной '${name}'.`);
|
|
230
|
+
}
|
|
144
231
|
const getChannel = IpcChannel.prop.get(name);
|
|
145
232
|
const setChannel = IpcChannel.prop.set(name);
|
|
146
|
-
const
|
|
147
|
-
|
|
233
|
+
const setter = typeof descriptor.set === 'function' ? descriptor.set : undefined;
|
|
234
|
+
const getter = 'value' in descriptor
|
|
235
|
+
? () => descriptor.value
|
|
236
|
+
: typeof descriptor.get === 'function'
|
|
237
|
+
? descriptor.get
|
|
238
|
+
: undefined;
|
|
148
239
|
entitiesInfo.variables.add(name);
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
240
|
+
// При повторной публикации старые обработчики должны быть удалены,
|
|
241
|
+
// иначе останется висеть доступ к прежнему значению.
|
|
242
|
+
ipcMain.removeAllListeners(getChannel);
|
|
243
|
+
ipcMain.removeAllListeners(setChannel);
|
|
244
|
+
ipcMain.on(getChannel, e => {
|
|
245
|
+
const event = new IpcEventInMain(e);
|
|
246
|
+
if (!getter) {
|
|
247
|
+
event.return(IpcResult.createWithError(new NoGetAccessError(name)));
|
|
248
|
+
return;
|
|
249
|
+
}
|
|
250
|
+
try {
|
|
251
|
+
event.return(createValueResult(getter()));
|
|
252
|
+
}
|
|
253
|
+
catch (error) {
|
|
254
|
+
event.return(IpcResult.createWithError(error));
|
|
255
|
+
}
|
|
256
|
+
});
|
|
257
|
+
ipcMain.on(setChannel, (e, payload) => {
|
|
258
|
+
const event = new IpcEventInMain(e);
|
|
259
|
+
if (!setter) {
|
|
260
|
+
event.return(IpcResult.createWithError(new TrySetReadonlyError(name)));
|
|
261
|
+
return;
|
|
262
|
+
}
|
|
263
|
+
const request = IpcPayload.request(payload);
|
|
264
|
+
if (!request) {
|
|
265
|
+
event.return(IpcResult.createWithError(new TypeError('Некорректный запрос установки переменной.')));
|
|
266
|
+
return;
|
|
267
|
+
}
|
|
268
|
+
try {
|
|
269
|
+
setter(request.args.at(0));
|
|
270
|
+
event.return(IpcResult.createWithValue(null));
|
|
271
|
+
}
|
|
272
|
+
catch (error) {
|
|
273
|
+
event.return(IpcResult.createWithError(error));
|
|
274
|
+
}
|
|
275
|
+
});
|
|
177
276
|
}
|
|
@@ -1,10 +1,10 @@
|
|
|
1
|
-
import type { EventListener, EventUnsubscribe, IBridge, IResult } from '../../types.js';
|
|
1
|
+
import type { EventListener, EventUnsubscribe, IBridge, IEntitiesInfo, IResult } from '../../types.js';
|
|
2
2
|
import BaseBridge from '../base-bridge.js';
|
|
3
3
|
/**
|
|
4
4
|
* Мост preload-main.
|
|
5
5
|
*/
|
|
6
6
|
export declare class PreloadBridge extends BaseBridge {
|
|
7
|
-
protected readonly entitiesInfo:
|
|
7
|
+
protected readonly entitiesInfo: IEntitiesInfo;
|
|
8
8
|
/**
|
|
9
9
|
* Создать мост preload-main.
|
|
10
10
|
*/
|
|
@@ -1,21 +1,23 @@
|
|
|
1
1
|
import { ipcRenderer } from 'electron';
|
|
2
2
|
import { NotProvidedFromMainError, TryUseBridgeInMainError } from '../../errors.js';
|
|
3
3
|
import BaseBridge from '../base-bridge.js';
|
|
4
|
-
import { Errors, IpcChannel, Transfer } from '../helpers/index.js';
|
|
4
|
+
import { EntitiesInfo, Errors, IpcChannel, Names, Transfer } from '../helpers/index.js';
|
|
5
5
|
import IPCTunnel from '../renderer/tunnels.js';
|
|
6
6
|
/**
|
|
7
7
|
* Мост preload-main.
|
|
8
8
|
*/
|
|
9
9
|
export class PreloadBridge extends BaseBridge {
|
|
10
|
+
entitiesInfo;
|
|
10
11
|
/**
|
|
11
12
|
* Создать мост preload-main.
|
|
12
13
|
*/
|
|
13
14
|
constructor() {
|
|
14
15
|
super();
|
|
15
|
-
|
|
16
|
-
if (!
|
|
16
|
+
const info = EntitiesInfo.read(ipcRenderer.sendSync(IpcChannel.publicInfo.get()));
|
|
17
|
+
if (!info) {
|
|
17
18
|
throw new NotProvidedFromMainError();
|
|
18
19
|
}
|
|
20
|
+
this.entitiesInfo = info;
|
|
19
21
|
this.init();
|
|
20
22
|
}
|
|
21
23
|
callFunction(name, secret, args) {
|
|
@@ -37,11 +39,10 @@ export class PreloadBridge extends BaseBridge {
|
|
|
37
39
|
: tunnel.once(listener);
|
|
38
40
|
}
|
|
39
41
|
emitEvent(name, value) {
|
|
42
|
+
Names.validateEvent(name);
|
|
40
43
|
const tunnel = new IPCTunnel.Event(name);
|
|
41
|
-
if (value
|
|
42
|
-
value
|
|
43
|
-
.then(val => tunnel.emit(Transfer.toTransferable(val)))
|
|
44
|
-
.catch(reason => tunnel.error(String(reason)));
|
|
44
|
+
if (Transfer.isPromiseLike(value)) {
|
|
45
|
+
value.then(result => tunnel.emit(Transfer.toTransferable(result)), reason => tunnel.error(reason));
|
|
45
46
|
}
|
|
46
47
|
else {
|
|
47
48
|
tunnel.emit(value);
|
|
@@ -1,7 +1,14 @@
|
|
|
1
1
|
import { contextBridge, ipcRenderer } from 'electron';
|
|
2
2
|
import { NotProvidedFromMainError, TryProvideInMainError, TryProvideInRendererError } from '../../errors.js';
|
|
3
|
-
import { Errors, IpcChannel, Transfer } from '../helpers/index.js';
|
|
3
|
+
import { EntitiesInfo, Errors, IpcChannel, Names, Transfer } from '../helpers/index.js';
|
|
4
4
|
import IPCTunnel from '../renderer/tunnels.js';
|
|
5
|
+
/**
|
|
6
|
+
* Максимальное число отслеживаемых каналов обещаний.
|
|
7
|
+
*
|
|
8
|
+
* Защищает от роста множества, если renderer вызывает функции,
|
|
9
|
+
* но никогда не ожидает их результат.
|
|
10
|
+
*/
|
|
11
|
+
const MAX_PENDING_PROMISES = 1024;
|
|
5
12
|
/**
|
|
6
13
|
* Бросить ошибку если есть повод.
|
|
7
14
|
*/
|
|
@@ -12,6 +19,17 @@ if (!ipcRenderer) {
|
|
|
12
19
|
else if (!contextBridge) {
|
|
13
20
|
throwPossibleError = Errors.getThrower(TryProvideInRendererError);
|
|
14
21
|
}
|
|
22
|
+
/**
|
|
23
|
+
* Был ли провайдер уже добавлен.
|
|
24
|
+
*/
|
|
25
|
+
let isProvided = false;
|
|
26
|
+
/**
|
|
27
|
+
* Каналы обещаний, выданные текущим вызовам.
|
|
28
|
+
*
|
|
29
|
+
* `waitPromise` доступен странице, поэтому он не должен позволять
|
|
30
|
+
* подписываться на произвольные IPC-каналы main процесса.
|
|
31
|
+
*/
|
|
32
|
+
const pendingPromiseChannels = new Set();
|
|
15
33
|
/**
|
|
16
34
|
* Добавляет необходимые для работы функции.
|
|
17
35
|
*
|
|
@@ -19,32 +37,74 @@ else if (!contextBridge) {
|
|
|
19
37
|
*/
|
|
20
38
|
function provideFromMain(contextIsolation = true) {
|
|
21
39
|
throwPossibleError();
|
|
22
|
-
|
|
40
|
+
if (isProvided) {
|
|
41
|
+
return;
|
|
42
|
+
}
|
|
43
|
+
const entitiesInfo = EntitiesInfo.read(ipcRenderer.sendSync(IpcChannel.publicInfo.get()));
|
|
23
44
|
if (!entitiesInfo) {
|
|
24
45
|
throw new NotProvidedFromMainError();
|
|
25
46
|
}
|
|
26
47
|
const provider = {
|
|
27
|
-
getEntitiesInfo: () =>
|
|
28
|
-
|
|
29
|
-
.
|
|
30
|
-
|
|
48
|
+
getEntitiesInfo: () => ({
|
|
49
|
+
variables: new Set(entitiesInfo.variables),
|
|
50
|
+
functions: new Set(entitiesInfo.functions)
|
|
51
|
+
}),
|
|
52
|
+
waitPromise: (channel, resolve, reject, id) => {
|
|
53
|
+
if (!pendingPromiseChannels.has(channel)) {
|
|
54
|
+
const error = new Error(`Неизвестный канал обещания '${String(channel)}'.`);
|
|
55
|
+
if (typeof reject === 'function') {
|
|
56
|
+
reject(error);
|
|
57
|
+
}
|
|
58
|
+
else {
|
|
59
|
+
console.error(error);
|
|
60
|
+
}
|
|
61
|
+
return;
|
|
62
|
+
}
|
|
63
|
+
pendingPromiseChannels.delete(channel);
|
|
64
|
+
new IPCTunnel.Promise(channel).wait(id).then(value => {
|
|
65
|
+
try {
|
|
66
|
+
resolve(value);
|
|
67
|
+
}
|
|
68
|
+
catch (error) {
|
|
69
|
+
console.error(error);
|
|
70
|
+
}
|
|
71
|
+
}, reason => {
|
|
72
|
+
if (typeof reject !== 'function') {
|
|
73
|
+
console.error(reason);
|
|
74
|
+
return;
|
|
75
|
+
}
|
|
76
|
+
try {
|
|
77
|
+
reject(reason);
|
|
78
|
+
}
|
|
79
|
+
catch (error) {
|
|
80
|
+
console.error(error);
|
|
81
|
+
}
|
|
82
|
+
});
|
|
83
|
+
},
|
|
31
84
|
entities: {
|
|
32
|
-
functions: getFunctions(),
|
|
33
|
-
variables: getVariables(),
|
|
85
|
+
functions: getFunctions(entitiesInfo),
|
|
86
|
+
variables: getVariables(entitiesInfo),
|
|
34
87
|
events: {
|
|
35
88
|
emit: (name, value) => {
|
|
89
|
+
Names.validateEvent(name);
|
|
36
90
|
const tunnel = new IPCTunnel.Event(name);
|
|
37
|
-
if (value
|
|
38
|
-
value
|
|
39
|
-
.then(val => tunnel.emit(Transfer.toTransferable(val)))
|
|
40
|
-
.catch(reason => tunnel.error(String(reason)));
|
|
91
|
+
if (Transfer.isPromiseLike(value)) {
|
|
92
|
+
value.then(result => tunnel.emit(Transfer.toTransferable(result)), reason => tunnel.error(reason));
|
|
41
93
|
}
|
|
42
94
|
else {
|
|
43
95
|
tunnel.emit(value);
|
|
44
96
|
}
|
|
45
97
|
},
|
|
46
|
-
on: (name, listener) =>
|
|
47
|
-
|
|
98
|
+
on: (name, listener) => {
|
|
99
|
+
Names.validateEvent(name);
|
|
100
|
+
assertListener(listener);
|
|
101
|
+
return new IPCTunnel.Event(name).on(listener);
|
|
102
|
+
},
|
|
103
|
+
once: (name, listener) => {
|
|
104
|
+
Names.validateEvent(name);
|
|
105
|
+
assertListener(listener);
|
|
106
|
+
return new IPCTunnel.Event(name).once(listener);
|
|
107
|
+
}
|
|
48
108
|
}
|
|
49
109
|
}
|
|
50
110
|
};
|
|
@@ -52,26 +112,39 @@ function provideFromMain(contextIsolation = true) {
|
|
|
52
112
|
contextBridge.exposeInMainWorld('__provider__', provider);
|
|
53
113
|
}
|
|
54
114
|
else {
|
|
115
|
+
if (typeof window === 'undefined') {
|
|
116
|
+
throw new TryProvideInRendererError();
|
|
117
|
+
}
|
|
55
118
|
window.__provider__ = provider;
|
|
56
119
|
}
|
|
120
|
+
isProvided = true;
|
|
57
121
|
/**
|
|
58
122
|
* Получить доступ к публичным функциям.
|
|
123
|
+
* @param info - Информация о сущностях.
|
|
59
124
|
*/
|
|
60
|
-
function getFunctions() {
|
|
125
|
+
function getFunctions(info) {
|
|
61
126
|
const result = {};
|
|
62
|
-
for (const name of
|
|
127
|
+
for (const name of info.functions) {
|
|
63
128
|
result[name] = (id, args) => {
|
|
64
|
-
|
|
129
|
+
if (typeof id !== 'string' || !Array.isArray(args)) {
|
|
130
|
+
throw new TypeError('Некорректные аргументы вызова функции моста.');
|
|
131
|
+
}
|
|
132
|
+
const response = new IPCTunnel.Function(name).call({ args, id });
|
|
133
|
+
if (IpcChannel.promise.is(response.promiseChannel)) {
|
|
134
|
+
rememberPromiseChannel(response.promiseChannel);
|
|
135
|
+
}
|
|
136
|
+
return response;
|
|
65
137
|
};
|
|
66
138
|
}
|
|
67
139
|
return result;
|
|
68
140
|
}
|
|
69
141
|
/**
|
|
70
142
|
* Получить доступ к публичным переменным.
|
|
143
|
+
* @param info - Информация о сущностях.
|
|
71
144
|
*/
|
|
72
|
-
function getVariables() {
|
|
145
|
+
function getVariables(info) {
|
|
73
146
|
const result = {};
|
|
74
|
-
for (const name of
|
|
147
|
+
for (const name of info.variables) {
|
|
75
148
|
const tunnel = new IPCTunnel.Variable(name);
|
|
76
149
|
result[name] = {
|
|
77
150
|
get: () => tunnel.get(),
|
|
@@ -81,4 +154,26 @@ function provideFromMain(contextIsolation = true) {
|
|
|
81
154
|
return result;
|
|
82
155
|
}
|
|
83
156
|
}
|
|
157
|
+
/**
|
|
158
|
+
* Запомнить выданный канал обещания.
|
|
159
|
+
* @param channel - Канал.
|
|
160
|
+
*/
|
|
161
|
+
function rememberPromiseChannel(channel) {
|
|
162
|
+
if (pendingPromiseChannels.size >= MAX_PENDING_PROMISES) {
|
|
163
|
+
const oldest = pendingPromiseChannels.values().next().value;
|
|
164
|
+
if (oldest !== undefined) {
|
|
165
|
+
pendingPromiseChannels.delete(oldest);
|
|
166
|
+
}
|
|
167
|
+
}
|
|
168
|
+
pendingPromiseChannels.add(channel);
|
|
169
|
+
}
|
|
170
|
+
/**
|
|
171
|
+
* Проверить, что обработчик события является функцией.
|
|
172
|
+
* @param listener - Обработчик.
|
|
173
|
+
*/
|
|
174
|
+
function assertListener(listener) {
|
|
175
|
+
if (typeof listener !== 'function') {
|
|
176
|
+
throw new TypeError('Обработчик события должен быть функцией.');
|
|
177
|
+
}
|
|
178
|
+
}
|
|
84
179
|
export default provideFromMain;
|
|
@@ -70,6 +70,9 @@ declare class PromiseTunnel {
|
|
|
70
70
|
* Туннель для события.
|
|
71
71
|
*/
|
|
72
72
|
declare class EventTunnel {
|
|
73
|
+
/**
|
|
74
|
+
* Имя события.
|
|
75
|
+
*/
|
|
73
76
|
private readonly name;
|
|
74
77
|
/**
|
|
75
78
|
* Туннель вызова события.
|
|
@@ -83,6 +86,10 @@ declare class EventTunnel {
|
|
|
83
86
|
* Туннель однократной обработки события.
|
|
84
87
|
*/
|
|
85
88
|
private readonly onceTunnel;
|
|
89
|
+
/**
|
|
90
|
+
* Туннель отписки от события.
|
|
91
|
+
*/
|
|
92
|
+
private readonly offTunnel;
|
|
86
93
|
/**
|
|
87
94
|
* Создать туннель для события.
|
|
88
95
|
* @param name - Имя события.
|
|
@@ -109,13 +116,19 @@ declare class EventTunnel {
|
|
|
109
116
|
* Бросить ошибку.
|
|
110
117
|
* @param error - Ошибка.
|
|
111
118
|
*/
|
|
112
|
-
error(error:
|
|
119
|
+
error(error: unknown): void;
|
|
120
|
+
/**
|
|
121
|
+
* Подписаться на событие.
|
|
122
|
+
* @param listener - Обработчик события.
|
|
123
|
+
* @param isOnce - Одноразовая подписка.
|
|
124
|
+
* @returns Функция отписки от события.
|
|
125
|
+
*/
|
|
126
|
+
private subscribe;
|
|
113
127
|
}
|
|
114
128
|
/**
|
|
115
129
|
* IPC туннель.
|
|
116
130
|
*/
|
|
117
131
|
export default class IPCTunnel {
|
|
118
|
-
private channel;
|
|
119
132
|
/**
|
|
120
133
|
* Туннель для функции.
|
|
121
134
|
*/
|
|
@@ -132,6 +145,10 @@ export default class IPCTunnel {
|
|
|
132
145
|
* Туннель для события.
|
|
133
146
|
*/
|
|
134
147
|
static readonly Event: typeof EventTunnel;
|
|
148
|
+
/**
|
|
149
|
+
* Канал.
|
|
150
|
+
*/
|
|
151
|
+
private readonly channel;
|
|
135
152
|
/**
|
|
136
153
|
* Создать IPC туннель.
|
|
137
154
|
* @param channel - Канал.
|