@lvce-editor/iframe-worker 3.2.0 → 3.3.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.
Files changed (2) hide show
  1. package/dist/iframeWorkerMain.js +656 -702
  2. package/package.json +1 -1
package/dist/iframeWorkerMain.js CHANGED
@@ -1,747 +1,746 @@
1
- const Two = '2.0';
2
- const create$4 = (method, params) => {
3
- return {
4
- jsonrpc: Two,
5
- method,
6
- params
1
+ const normalizeLine = line => {
2
+ if (line.startsWith('Error: ')) {
3
+ return line.slice('Error: '.length);
4
+ }
5
+ if (line.startsWith('VError: ')) {
6
+ return line.slice('VError: '.length);
7
+ }
8
+ return line;
9
+ };
10
+ const getCombinedMessage = (error, message) => {
11
+ const stringifiedError = normalizeLine(`${error}`);
12
+ if (message) {
13
+ return `${message}: ${stringifiedError}`;
14
+ }
15
+ return stringifiedError;
16
+ };
17
+ const NewLine$2 = '\n';
18
+ const getNewLineIndex$1 = (string, startIndex = undefined) => {
19
+ return string.indexOf(NewLine$2, startIndex);
20
+ };
21
+ const mergeStacks = (parent, child) => {
22
+ if (!child) {
23
+ return parent;
24
+ }
25
+ const parentNewLineIndex = getNewLineIndex$1(parent);
26
+ const childNewLineIndex = getNewLineIndex$1(child);
27
+ if (childNewLineIndex === -1) {
28
+ return parent;
29
+ }
30
+ const parentFirstLine = parent.slice(0, parentNewLineIndex);
31
+ const childRest = child.slice(childNewLineIndex);
32
+ const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
33
+ if (parentFirstLine.includes(childFirstLine)) {
34
+ return parentFirstLine + childRest;
35
+ }
36
+ return child;
37
+ };
38
+ class VError extends Error {
39
+ constructor(error, message) {
40
+ const combinedMessage = getCombinedMessage(error, message);
41
+ super(combinedMessage);
42
+ this.name = 'VError';
43
+ if (error instanceof Error) {
44
+ this.stack = mergeStacks(this.stack, error.stack);
45
+ }
46
+ if (error.codeFrame) {
47
+ // @ts-ignore
48
+ this.codeFrame = error.codeFrame;
49
+ }
50
+ if (error.code) {
51
+ // @ts-ignore
52
+ this.code = error.code;
53
+ }
54
+ }
55
+ }
56
+
57
+ const walkValue = (value, transferrables, isTransferrable) => {
58
+ if (!value) {
59
+ return;
60
+ }
61
+ if (isTransferrable(value)) {
62
+ transferrables.push(value);
63
+ return;
64
+ }
65
+ if (Array.isArray(value)) {
66
+ for (const item of value) {
67
+ walkValue(item, transferrables, isTransferrable);
68
+ }
69
+ return;
70
+ }
71
+ if (typeof value === 'object') {
72
+ for (const property of Object.values(value)) {
73
+ walkValue(property, transferrables, isTransferrable);
74
+ }
75
+ return;
76
+ }
77
+ };
78
+ const isMessagePort = value => {
79
+ return value && value instanceof MessagePort;
80
+ };
81
+ const isMessagePortMain = value => {
82
+ return value && value.constructor && value.constructor.name === 'MessagePortMain';
83
+ };
84
+ const isOffscreenCanvas = value => {
85
+ return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
86
+ };
87
+ const isInstanceOf = (value, constructorName) => {
88
+ return value?.constructor?.name === constructorName;
89
+ };
90
+ const isSocket = value => {
91
+ return isInstanceOf(value, 'Socket');
92
+ };
93
+ const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
94
+ const isTransferrable = value => {
95
+ for (const fn of transferrables) {
96
+ if (fn(value)) {
97
+ return true;
98
+ }
99
+ }
100
+ return false;
101
+ };
102
+ const getTransferrables = value => {
103
+ const transferrables = [];
104
+ walkValue(value, transferrables, isTransferrable);
105
+ return transferrables;
106
+ };
107
+ const attachEvents = that => {
108
+ const handleMessage = (...args) => {
109
+ const data = that.getData(...args);
110
+ that.dispatchEvent(new MessageEvent('message', {
111
+ data
112
+ }));
113
+ };
114
+ that.onMessage(handleMessage);
115
+ const handleClose = event => {
116
+ that.dispatchEvent(new Event('close'));
7
117
  };
118
+ that.onClose(handleClose);
8
119
  };
9
- const state$2 = {
10
- callbacks: Object.create(null)
120
+ class Ipc extends EventTarget {
121
+ constructor(rawIpc) {
122
+ super();
123
+ this._rawIpc = rawIpc;
124
+ attachEvents(this);
125
+ }
126
+ }
127
+ const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
128
+ const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
129
+ const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
130
+ const NewLine$1 = '\n';
131
+ const joinLines$1 = lines => {
132
+ return lines.join(NewLine$1);
11
133
  };
12
- const set = (id, fn) => {
13
- state$2.callbacks[id] = fn;
134
+ const splitLines$1 = lines => {
135
+ return lines.split(NewLine$1);
14
136
  };
15
- const get = id => {
16
- return state$2.callbacks[id];
137
+ const isModuleNotFoundMessage = line => {
138
+ return line.includes('[ERR_MODULE_NOT_FOUND]');
17
139
  };
18
- const remove = id => {
19
- delete state$2.callbacks[id];
140
+ const getModuleNotFoundError = stderr => {
141
+ const lines = splitLines$1(stderr);
142
+ const messageIndex = lines.findIndex(isModuleNotFoundMessage);
143
+ const message = lines[messageIndex];
144
+ return {
145
+ message,
146
+ code: ERR_MODULE_NOT_FOUND
147
+ };
20
148
  };
21
- let id = 0;
22
- const create$3 = () => {
23
- return ++id;
149
+ const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
150
+ const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
151
+ const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
152
+ const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
153
+ const RE_AT = /^\s+at/;
154
+ const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
155
+ const isUnhelpfulNativeModuleError = stderr => {
156
+ return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
24
157
  };
25
- const warn = (...args) => {
26
- console.warn(...args);
158
+ const isMessageCodeBlockStartIndex = line => {
159
+ return RE_MESSAGE_CODE_BLOCK_START.test(line);
27
160
  };
28
- const registerPromise = () => {
29
- const id = create$3();
30
- const {
31
- resolve,
32
- promise
33
- } = Promise.withResolvers();
34
- set(id, resolve);
161
+ const isMessageCodeBlockEndIndex = line => {
162
+ return RE_MESSAGE_CODE_BLOCK_END.test(line);
163
+ };
164
+ const getMessageCodeBlock = stderr => {
165
+ const lines = splitLines$1(stderr);
166
+ const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
167
+ const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
168
+ const relevantLines = lines.slice(startIndex, endIndex);
169
+ const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
170
+ return relevantMessage;
171
+ };
172
+ const getNativeModuleErrorMessage = stderr => {
173
+ const message = getMessageCodeBlock(stderr);
35
174
  return {
36
- id,
37
- promise
175
+ message: `Incompatible native node module: ${message}`,
176
+ code: E_INCOMPATIBLE_NATIVE_MODULE
38
177
  };
39
178
  };
40
- const resolve = (id, response) => {
41
- const fn = get(id);
42
- if (!fn) {
43
- console.log(response);
44
- warn(`callback ${id} may already be disposed`);
45
- return;
179
+ const isModulesSyntaxError = stderr => {
180
+ if (!stderr) {
181
+ return false;
46
182
  }
47
- fn(response);
48
- remove(id);
183
+ return stderr.includes('SyntaxError: Cannot use import statement outside a module');
49
184
  };
50
- const create$2 = (method, params) => {
51
- const {
52
- id,
53
- promise
54
- } = registerPromise();
55
- const message = {
56
- jsonrpc: Two,
57
- method,
58
- params,
59
- id
60
- };
185
+ const getModuleSyntaxError = () => {
61
186
  return {
62
- message,
63
- promise
187
+ message: `ES Modules are not supported in electron`,
188
+ code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
64
189
  };
65
190
  };
66
- class JsonRpcError extends Error {
67
- constructor(message) {
68
- super(message);
69
- this.name = 'JsonRpcError';
191
+ const isModuleNotFoundError = stderr => {
192
+ if (!stderr) {
193
+ return false;
70
194
  }
71
- }
72
- const NewLine$3 = '\n';
73
- const DomException = 'DOMException';
74
- const ReferenceError$1 = 'ReferenceError';
75
- const SyntaxError$1 = 'SyntaxError';
76
- const TypeError$1 = 'TypeError';
77
- const getErrorConstructor = (message, type) => {
78
- if (type) {
79
- switch (type) {
80
- case DomException:
81
- return DOMException;
82
- case TypeError$1:
83
- return TypeError;
84
- case SyntaxError$1:
85
- return SyntaxError;
86
- case ReferenceError$1:
87
- return ReferenceError;
88
- default:
89
- return Error;
195
+ return stderr.includes('ERR_MODULE_NOT_FOUND');
196
+ };
197
+ const isNormalStackLine = line => {
198
+ return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
199
+ };
200
+ const getDetails = lines => {
201
+ const index = lines.findIndex(isNormalStackLine);
202
+ if (index === -1) {
203
+ return {
204
+ actualMessage: joinLines$1(lines),
205
+ rest: []
206
+ };
207
+ }
208
+ let lastIndex = index - 1;
209
+ while (++lastIndex < lines.length) {
210
+ if (!isNormalStackLine(lines[lastIndex])) {
211
+ break;
90
212
  }
91
213
  }
92
- if (message.startsWith('TypeError: ')) {
93
- return TypeError;
214
+ return {
215
+ actualMessage: lines[index - 1],
216
+ rest: lines.slice(index, lastIndex)
217
+ };
218
+ };
219
+ const getHelpfulChildProcessError = (stdout, stderr) => {
220
+ if (isUnhelpfulNativeModuleError(stderr)) {
221
+ return getNativeModuleErrorMessage(stderr);
94
222
  }
95
- if (message.startsWith('SyntaxError: ')) {
96
- return SyntaxError;
223
+ if (isModulesSyntaxError(stderr)) {
224
+ return getModuleSyntaxError();
97
225
  }
98
- if (message.startsWith('ReferenceError: ')) {
99
- return ReferenceError;
226
+ if (isModuleNotFoundError(stderr)) {
227
+ return getModuleNotFoundError(stderr);
100
228
  }
101
- return Error;
229
+ const lines = splitLines$1(stderr);
230
+ const {
231
+ actualMessage,
232
+ rest
233
+ } = getDetails(lines);
234
+ return {
235
+ message: `${actualMessage}`,
236
+ code: '',
237
+ stack: rest
238
+ };
102
239
  };
103
- const constructError = (message, type, name) => {
104
- const ErrorConstructor = getErrorConstructor(message, type);
105
- if (ErrorConstructor === DOMException && name) {
106
- return new ErrorConstructor(message, name);
107
- }
108
- if (ErrorConstructor === Error) {
109
- const error = new Error(message);
110
- if (name && name !== 'VError') {
111
- error.name = name;
240
+ class IpcError extends VError {
241
+ // @ts-ignore
242
+ constructor(betterMessage, stdout = '', stderr = '') {
243
+ if (stdout || stderr) {
244
+ // @ts-ignore
245
+ const {
246
+ message,
247
+ code,
248
+ stack
249
+ } = getHelpfulChildProcessError(stdout, stderr);
250
+ const cause = new Error(message);
251
+ // @ts-ignore
252
+ cause.code = code;
253
+ cause.stack = stack;
254
+ super(cause, betterMessage);
255
+ } else {
256
+ super(betterMessage);
112
257
  }
113
- return error;
258
+ // @ts-ignore
259
+ this.name = 'IpcError';
260
+ // @ts-ignore
261
+ this.stdout = stdout;
262
+ // @ts-ignore
263
+ this.stderr = stderr;
114
264
  }
115
- return new ErrorConstructor(message);
116
- };
117
- const getNewLineIndex$2 = (string, startIndex = undefined) => {
118
- return string.indexOf(NewLine$3, startIndex);
265
+ }
266
+ const readyMessage = 'ready';
267
+ const getData$2 = event => {
268
+ return event.data;
119
269
  };
120
- const getParentStack = error => {
121
- let parentStack = error.stack || error.data || error.message || '';
122
- if (parentStack.startsWith(' at')) {
123
- parentStack = error.message + NewLine$3 + parentStack;
270
+ const listen$6 = () => {
271
+ // @ts-ignore
272
+ if (typeof WorkerGlobalScope === 'undefined') {
273
+ throw new TypeError('module is not in web worker scope');
124
274
  }
125
- return parentStack;
126
- };
127
- const joinLines$1 = lines => {
128
- return lines.join(NewLine$3);
275
+ return globalThis;
129
276
  };
130
- const MethodNotFound = -32601;
131
- const Custom = -32001;
132
- const splitLines$1 = lines => {
133
- return lines.split(NewLine$3);
277
+ const signal$6 = global => {
278
+ global.postMessage(readyMessage);
134
279
  };
135
- const restoreJsonRpcError = error => {
136
- if (error && error instanceof Error) {
137
- return error;
280
+ class IpcChildWithModuleWorker extends Ipc {
281
+ getData(event) {
282
+ return getData$2(event);
138
283
  }
139
- const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(1));
140
- if (error && error.code && error.code === MethodNotFound) {
141
- const restoredError = new JsonRpcError(error.message);
142
- const parentStack = getParentStack(error);
143
- restoredError.stack = parentStack + NewLine$3 + currentStack;
144
- return restoredError;
284
+ send(message) {
285
+ // @ts-ignore
286
+ this._rawIpc.postMessage(message);
145
287
  }
146
- if (error && error.message) {
147
- const restoredError = constructError(error.message, error.type, error.name);
148
- if (error.data) {
149
- if (error.data.stack && error.data.type && error.message) {
150
- restoredError.stack = error.data.type + ': ' + error.message + NewLine$3 + error.data.stack + NewLine$3 + currentStack;
151
- } else if (error.data.stack) {
152
- restoredError.stack = error.data.stack;
153
- }
154
- if (error.data.codeFrame) {
155
- // @ts-ignore
156
- restoredError.codeFrame = error.data.codeFrame;
157
- }
158
- if (error.data.code) {
159
- // @ts-ignore
160
- restoredError.code = error.data.code;
161
- }
162
- if (error.data.type) {
163
- // @ts-ignore
164
- restoredError.name = error.data.type;
165
- }
166
- } else {
167
- if (error.stack) {
168
- const lowerStack = restoredError.stack || '';
169
- // @ts-ignore
170
- const indexNewLine = getNewLineIndex$2(lowerStack);
171
- const parentStack = getParentStack(error);
172
- // @ts-ignore
173
- restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
174
- }
175
- if (error.codeFrame) {
176
- // @ts-ignore
177
- restoredError.codeFrame = error.codeFrame;
178
- }
179
- }
180
- return restoredError;
288
+ sendAndTransfer(message) {
289
+ const transfer = getTransferrables(message);
290
+ // @ts-ignore
291
+ this._rawIpc.postMessage(message, transfer);
181
292
  }
182
- if (typeof error === 'string') {
183
- return new Error(`JsonRpc Error: ${error}`);
293
+ dispose() {
294
+ // ignore
184
295
  }
185
- return new Error(`JsonRpc Error: ${error}`);
186
- };
187
- const unwrapJsonRpcResult = responseMessage => {
188
- if ('error' in responseMessage) {
189
- const restoredError = restoreJsonRpcError(responseMessage.error);
190
- throw restoredError;
296
+ onClose(callback) {
297
+ // ignore
191
298
  }
192
- if ('result' in responseMessage) {
193
- return responseMessage.result;
299
+ onMessage(callback) {
300
+ this._rawIpc.addEventListener('message', callback);
194
301
  }
195
- throw new JsonRpcError('unexpected response message');
302
+ }
303
+ const wrap$d = global => {
304
+ return new IpcChildWithModuleWorker(global);
196
305
  };
197
- const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
198
- const getErrorType = prettyError => {
199
- if (prettyError && prettyError.type) {
200
- return prettyError.type;
306
+ const withResolvers = () => {
307
+ let _resolve;
308
+ const promise = new Promise(resolve => {
309
+ _resolve = resolve;
310
+ });
311
+ return {
312
+ resolve: _resolve,
313
+ promise
314
+ };
315
+ };
316
+ const waitForFirstMessage = async port => {
317
+ const {
318
+ resolve,
319
+ promise
320
+ } = withResolvers();
321
+ port.addEventListener('message', resolve, {
322
+ once: true
323
+ });
324
+ const event = await promise;
325
+ // @ts-ignore
326
+ return event.data;
327
+ };
328
+ const listen$5 = async () => {
329
+ const parentIpcRaw = listen$6();
330
+ signal$6(parentIpcRaw);
331
+ const parentIpc = wrap$d(parentIpcRaw);
332
+ const firstMessage = await waitForFirstMessage(parentIpc);
333
+ if (firstMessage.method !== 'initialize') {
334
+ throw new IpcError('unexpected first message');
201
335
  }
202
- if (prettyError && prettyError.constructor && prettyError.constructor.name) {
203
- return prettyError.constructor.name;
336
+ const type = firstMessage.params[0];
337
+ if (type === 'message-port') {
338
+ parentIpc.send({
339
+ jsonrpc: '2.0',
340
+ id: firstMessage.id,
341
+ result: null
342
+ });
343
+ parentIpc.dispose();
344
+ const port = firstMessage.params[1];
345
+ return port;
204
346
  }
205
- return undefined;
347
+ return globalThis;
206
348
  };
207
- const getErrorProperty = (error, prettyError) => {
208
- if (error && error.code === E_COMMAND_NOT_FOUND) {
209
- return {
210
- code: MethodNotFound,
211
- message: error.message,
212
- data: error.stack
213
- };
349
+ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
350
+ constructor(port) {
351
+ super(port);
214
352
  }
215
- return {
216
- code: Custom,
217
- message: prettyError.message,
218
- data: {
219
- stack: prettyError.stack,
220
- codeFrame: prettyError.codeFrame,
221
- type: getErrorType(prettyError),
222
- code: prettyError.code,
223
- name: prettyError.name
224
- }
225
- };
226
- };
227
- const create$1$2 = (message, error) => {
228
- return {
229
- jsonrpc: Two,
230
- id: message.id,
231
- error
232
- };
353
+ getData(event) {
354
+ return getData$2(event);
355
+ }
356
+ send(message) {
357
+ this._rawIpc.postMessage(message);
358
+ }
359
+ sendAndTransfer(message) {
360
+ const transfer = getTransferrables(message);
361
+ this._rawIpc.postMessage(message, transfer);
362
+ }
363
+ dispose() {
364
+ if (this._rawIpc.close) {
365
+ this._rawIpc.close();
366
+ }
367
+ }
368
+ onClose(callback) {
369
+ // ignore
370
+ }
371
+ onMessage(callback) {
372
+ this._rawIpc.addEventListener('message', callback);
373
+ this._rawIpc.start();
374
+ }
375
+ }
376
+ const wrap$c = port => {
377
+ return new IpcChildWithModuleWorkerAndMessagePort(port);
233
378
  };
234
- const getErrorResponse = (message, error, preparePrettyError, logError) => {
235
- const prettyError = preparePrettyError(error);
236
- logError(error, prettyError);
237
- const errorProperty = getErrorProperty(error, prettyError);
238
- return create$1$2(message, errorProperty);
379
+ const IpcChildWithModuleWorkerAndMessagePort$1 = {
380
+ __proto__: null,
381
+ listen: listen$5,
382
+ wrap: wrap$c
239
383
  };
240
- const create$5 = (message, result) => {
384
+
385
+ const Two = '2.0';
386
+ const create$4 = (method, params) => {
241
387
  return {
242
388
  jsonrpc: Two,
243
- id: message.id,
244
- result: result ?? null
389
+ method,
390
+ params
245
391
  };
246
392
  };
247
- const getSuccessResponse = (message, result) => {
248
- const resultProperty = result ?? null;
249
- return create$5(message, resultProperty);
393
+ const callbacks = Object.create(null);
394
+ const set = (id, fn) => {
395
+ callbacks[id] = fn;
250
396
  };
251
- const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
252
- try {
253
- const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
254
- return getSuccessResponse(message, result);
255
- } catch (error) {
256
- return getErrorResponse(message, error, preparePrettyError, logError);
257
- }
397
+ const get = id => {
398
+ return callbacks[id];
258
399
  };
259
- const defaultPreparePrettyError = error => {
260
- return error;
400
+ const remove = id => {
401
+ delete callbacks[id];
261
402
  };
262
- const defaultLogError = () => {
263
- // ignore
403
+ let id = 0;
404
+ const create$3 = () => {
405
+ return ++id;
264
406
  };
265
- const defaultRequiresSocket = () => {
266
- return false;
407
+ const warn = (...args) => {
408
+ console.warn(...args);
267
409
  };
268
- const defaultResolve = resolve;
269
-
270
- // TODO maybe remove this in v6 or v7, only accept options object to simplify the code
271
- const normalizeParams = args => {
272
- if (args.length === 1) {
273
- const options = args[0];
274
- return {
275
- ipc: options.ipc,
276
- message: options.message,
277
- execute: options.execute,
278
- resolve: options.resolve || defaultResolve,
279
- preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
280
- logError: options.logError || defaultLogError,
281
- requiresSocket: options.requiresSocket || defaultRequiresSocket
282
- };
283
- }
410
+ const registerPromise = () => {
411
+ const id = create$3();
412
+ const {
413
+ resolve,
414
+ promise
415
+ } = Promise.withResolvers();
416
+ set(id, resolve);
284
417
  return {
285
- ipc: args[0],
286
- message: args[1],
287
- execute: args[2],
288
- resolve: args[3],
289
- preparePrettyError: args[4],
290
- logError: args[5],
291
- requiresSocket: args[6]
418
+ id,
419
+ promise
292
420
  };
293
421
  };
294
- const handleJsonRpcMessage = async (...args) => {
295
- const options = normalizeParams(args);
296
- const {
297
- message,
298
- ipc,
299
- execute,
300
- resolve,
301
- preparePrettyError,
302
- logError,
303
- requiresSocket
304
- } = options;
305
- if ('id' in message) {
306
- if ('method' in message) {
307
- const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
308
- try {
309
- ipc.send(response);
310
- } catch (error) {
311
- const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
312
- ipc.send(errorResponse);
313
- }
314
- return;
315
- }
316
- resolve(message.id, message);
317
- return;
318
- }
319
- if ('method' in message) {
320
- await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
422
+ const resolve = (id, response) => {
423
+ const fn = get(id);
424
+ if (!fn) {
425
+ console.log(response);
426
+ warn(`callback ${id} may already be disposed`);
321
427
  return;
322
428
  }
323
- throw new JsonRpcError('unexpected message');
429
+ fn(response);
430
+ remove(id);
324
431
  };
325
- const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
432
+ const create$2$1 = (method, params) => {
326
433
  const {
327
- message,
434
+ id,
328
435
  promise
329
- } = create$2(method, params);
330
- if (useSendAndTransfer && ipc.sendAndTransfer) {
331
- ipc.sendAndTransfer(message);
332
- } else {
333
- ipc.send(message);
334
- }
335
- const responseMessage = await promise;
336
- return unwrapJsonRpcResult(responseMessage);
337
- };
338
- const send = (transport, method, ...params) => {
339
- const message = create$4(method, params);
340
- transport.send(message);
341
- };
342
- const invoke$4 = (ipc, method, ...params) => {
343
- return invokeHelper(ipc, method, params, false);
344
- };
345
- const invokeAndTransfer$3 = (ipc, method, ...params) => {
346
- return invokeHelper(ipc, method, params, true);
347
- };
348
-
349
- const commands = Object.create(null);
350
- const register$4 = commandMap => {
351
- Object.assign(commands, commandMap);
352
- };
353
- const getCommand = key => {
354
- return commands[key];
355
- };
356
- const execute = (command, ...args) => {
357
- const fn = getCommand(command);
358
- if (!fn) {
359
- throw new Error(`command not found ${command}`);
360
- }
361
- return fn(...args);
362
- };
363
-
364
- const getData$1 = event => {
365
- return event.data;
366
- };
367
- const attachEvents = that => {
368
- const handleMessage = (...args) => {
369
- const data = that.getData(...args);
370
- that.dispatchEvent(new MessageEvent('message', {
371
- data
372
- }));
436
+ } = registerPromise();
437
+ const message = {
438
+ jsonrpc: Two,
439
+ method,
440
+ params,
441
+ id
373
442
  };
374
- that.onMessage(handleMessage);
375
- const handleClose = event => {
376
- that.dispatchEvent(new Event('close'));
443
+ return {
444
+ message,
445
+ promise
377
446
  };
378
- that.onClose(handleClose);
379
447
  };
380
- class Ipc extends EventTarget {
381
- constructor(rawIpc) {
382
- super();
383
- this._rawIpc = rawIpc;
384
- attachEvents(this);
448
+ class JsonRpcError extends Error {
449
+ constructor(message) {
450
+ super(message);
451
+ this.name = 'JsonRpcError';
385
452
  }
386
453
  }
387
- const readyMessage = 'ready';
388
- const walkValue = (value, transferrables, isTransferrable) => {
389
- if (!value) {
390
- return;
454
+ const NewLine = '\n';
455
+ const DomException = 'DOMException';
456
+ const ReferenceError$1 = 'ReferenceError';
457
+ const SyntaxError$1 = 'SyntaxError';
458
+ const TypeError$1 = 'TypeError';
459
+ const getErrorConstructor = (message, type) => {
460
+ if (type) {
461
+ switch (type) {
462
+ case DomException:
463
+ return DOMException;
464
+ case TypeError$1:
465
+ return TypeError;
466
+ case SyntaxError$1:
467
+ return SyntaxError;
468
+ case ReferenceError$1:
469
+ return ReferenceError;
470
+ default:
471
+ return Error;
472
+ }
391
473
  }
392
- if (isTransferrable(value)) {
393
- transferrables.push(value);
394
- return;
474
+ if (message.startsWith('TypeError: ')) {
475
+ return TypeError;
395
476
  }
396
- if (Array.isArray(value)) {
397
- for (const item of value) {
398
- walkValue(item, transferrables, isTransferrable);
399
- }
400
- return;
477
+ if (message.startsWith('SyntaxError: ')) {
478
+ return SyntaxError;
401
479
  }
402
- if (typeof value === 'object') {
403
- for (const property of Object.values(value)) {
404
- walkValue(property, transferrables, isTransferrable);
405
- }
406
- return;
480
+ if (message.startsWith('ReferenceError: ')) {
481
+ return ReferenceError;
407
482
  }
483
+ return Error;
408
484
  };
409
- const isMessagePort = value => {
410
- return value && value instanceof MessagePort;
411
- };
412
- const isMessagePortMain = value => {
413
- return value && value.constructor && value.constructor.name === 'MessagePortMain';
414
- };
415
- const isOffscreenCanvas = value => {
416
- return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
417
- };
418
- const isInstanceOf = (value, constructorName) => {
419
- return value?.constructor?.name === constructorName;
420
- };
421
- const isSocket = value => {
422
- return isInstanceOf(value, 'Socket');
423
- };
424
- const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
425
- const isTransferrable = value => {
426
- for (const fn of transferrables) {
427
- if (fn(value)) {
428
- return true;
485
+ const constructError = (message, type, name) => {
486
+ const ErrorConstructor = getErrorConstructor(message, type);
487
+ if (ErrorConstructor === DOMException && name) {
488
+ return new ErrorConstructor(message, name);
489
+ }
490
+ if (ErrorConstructor === Error) {
491
+ const error = new Error(message);
492
+ if (name && name !== 'VError') {
493
+ error.name = name;
429
494
  }
495
+ return error;
430
496
  }
431
- return false;
497
+ return new ErrorConstructor(message);
432
498
  };
433
- const getTransferrables = value => {
434
- const transferrables = [];
435
- walkValue(value, transferrables, isTransferrable);
436
- return transferrables;
499
+ const getNewLineIndex = (string, startIndex = undefined) => {
500
+ return string.indexOf(NewLine, startIndex);
437
501
  };
438
- const listen$2 = () => {
439
- // @ts-ignore
440
- if (typeof WorkerGlobalScope === 'undefined') {
441
- throw new TypeError('module is not in web worker scope');
502
+ const getParentStack = error => {
503
+ let parentStack = error.stack || error.data || error.message || '';
504
+ if (parentStack.startsWith(' at')) {
505
+ parentStack = error.message + NewLine + parentStack;
442
506
  }
443
- return globalThis;
507
+ return parentStack;
444
508
  };
445
- const signal$2 = global => {
446
- global.postMessage(readyMessage);
509
+ const joinLines = lines => {
510
+ return lines.join(NewLine);
447
511
  };
448
- class IpcChildWithModuleWorker extends Ipc {
449
- getData(event) {
450
- return getData$1(event);
512
+ const MethodNotFound = -32601;
513
+ const Custom = -32001;
514
+ const splitLines = lines => {
515
+ return lines.split(NewLine);
516
+ };
517
+ const restoreJsonRpcError = error => {
518
+ if (error && error instanceof Error) {
519
+ return error;
451
520
  }
452
- send(message) {
453
- // @ts-ignore
454
- this._rawIpc.postMessage(message);
521
+ const currentStack = joinLines(splitLines(new Error().stack || '').slice(1));
522
+ if (error && error.code && error.code === MethodNotFound) {
523
+ const restoredError = new JsonRpcError(error.message);
524
+ const parentStack = getParentStack(error);
525
+ restoredError.stack = parentStack + NewLine + currentStack;
526
+ return restoredError;
455
527
  }
456
- sendAndTransfer(message) {
457
- const transfer = getTransferrables(message);
458
- // @ts-ignore
459
- this._rawIpc.postMessage(message, transfer);
528
+ if (error && error.message) {
529
+ const restoredError = constructError(error.message, error.type, error.name);
530
+ if (error.data) {
531
+ if (error.data.stack && error.data.type && error.message) {
532
+ restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
533
+ } else if (error.data.stack) {
534
+ restoredError.stack = error.data.stack;
535
+ }
536
+ if (error.data.codeFrame) {
537
+ // @ts-ignore
538
+ restoredError.codeFrame = error.data.codeFrame;
539
+ }
540
+ if (error.data.code) {
541
+ // @ts-ignore
542
+ restoredError.code = error.data.code;
543
+ }
544
+ if (error.data.type) {
545
+ // @ts-ignore
546
+ restoredError.name = error.data.type;
547
+ }
548
+ } else {
549
+ if (error.stack) {
550
+ const lowerStack = restoredError.stack || '';
551
+ // @ts-ignore
552
+ const indexNewLine = getNewLineIndex(lowerStack);
553
+ const parentStack = getParentStack(error);
554
+ // @ts-ignore
555
+ restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
556
+ }
557
+ if (error.codeFrame) {
558
+ // @ts-ignore
559
+ restoredError.codeFrame = error.codeFrame;
560
+ }
561
+ }
562
+ return restoredError;
460
563
  }
461
- dispose() {
462
- // ignore
564
+ if (typeof error === 'string') {
565
+ return new Error(`JsonRpc Error: ${error}`);
463
566
  }
464
- onClose(callback) {
465
- // ignore
567
+ return new Error(`JsonRpc Error: ${error}`);
568
+ };
569
+ const unwrapJsonRpcResult = responseMessage => {
570
+ if ('error' in responseMessage) {
571
+ const restoredError = restoreJsonRpcError(responseMessage.error);
572
+ throw restoredError;
466
573
  }
467
- onMessage(callback) {
468
- this._rawIpc.addEventListener('message', callback);
574
+ if ('result' in responseMessage) {
575
+ return responseMessage.result;
469
576
  }
470
- }
471
- const wrap$5 = global => {
472
- return new IpcChildWithModuleWorker(global);
473
- };
474
- const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
475
- const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
476
- const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
477
- const NewLine$1 = '\n';
478
- const joinLines = lines => {
479
- return lines.join(NewLine$1);
480
- };
481
- const splitLines = lines => {
482
- return lines.split(NewLine$1);
483
- };
484
- const isModuleNotFoundMessage = line => {
485
- return line.includes('[ERR_MODULE_NOT_FOUND]');
486
- };
487
- const getModuleNotFoundError = stderr => {
488
- const lines = splitLines(stderr);
489
- const messageIndex = lines.findIndex(isModuleNotFoundMessage);
490
- const message = lines[messageIndex];
491
- return {
492
- message,
493
- code: ERR_MODULE_NOT_FOUND
494
- };
495
- };
496
- const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
497
- const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
498
- const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
499
- const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
500
- const RE_AT = /^\s+at/;
501
- const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
502
- const isUnhelpfulNativeModuleError = stderr => {
503
- return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
504
- };
505
- const isMessageCodeBlockStartIndex = line => {
506
- return RE_MESSAGE_CODE_BLOCK_START.test(line);
507
- };
508
- const isMessageCodeBlockEndIndex = line => {
509
- return RE_MESSAGE_CODE_BLOCK_END.test(line);
510
- };
511
- const getMessageCodeBlock = stderr => {
512
- const lines = splitLines(stderr);
513
- const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
514
- const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
515
- const relevantLines = lines.slice(startIndex, endIndex);
516
- const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
517
- return relevantMessage;
518
- };
519
- const getNativeModuleErrorMessage = stderr => {
520
- const message = getMessageCodeBlock(stderr);
521
- return {
522
- message: `Incompatible native node module: ${message}`,
523
- code: E_INCOMPATIBLE_NATIVE_MODULE
524
- };
577
+ throw new JsonRpcError('unexpected response message');
525
578
  };
526
- const isModulesSyntaxError = stderr => {
527
- if (!stderr) {
528
- return false;
579
+ const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
580
+ const getErrorType = prettyError => {
581
+ if (prettyError && prettyError.type) {
582
+ return prettyError.type;
529
583
  }
530
- return stderr.includes('SyntaxError: Cannot use import statement outside a module');
531
- };
532
- const getModuleSyntaxError = () => {
533
- return {
534
- message: `ES Modules are not supported in electron`,
535
- code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
536
- };
537
- };
538
- const isModuleNotFoundError = stderr => {
539
- if (!stderr) {
540
- return false;
584
+ if (prettyError && prettyError.constructor && prettyError.constructor.name) {
585
+ return prettyError.constructor.name;
541
586
  }
542
- return stderr.includes('ERR_MODULE_NOT_FOUND');
543
- };
544
- const isNormalStackLine = line => {
545
- return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
587
+ return undefined;
546
588
  };
547
- const getDetails = lines => {
548
- const index = lines.findIndex(isNormalStackLine);
549
- if (index === -1) {
589
+ const getErrorProperty = (error, prettyError) => {
590
+ if (error && error.code === E_COMMAND_NOT_FOUND) {
550
591
  return {
551
- actualMessage: joinLines(lines),
552
- rest: []
592
+ code: MethodNotFound,
593
+ message: error.message,
594
+ data: error.stack
553
595
  };
554
596
  }
555
- let lastIndex = index - 1;
556
- while (++lastIndex < lines.length) {
557
- if (!isNormalStackLine(lines[lastIndex])) {
558
- break;
559
- }
560
- }
561
597
  return {
562
- actualMessage: lines[index - 1],
563
- rest: lines.slice(index, lastIndex)
598
+ code: Custom,
599
+ message: prettyError.message,
600
+ data: {
601
+ stack: prettyError.stack,
602
+ codeFrame: prettyError.codeFrame,
603
+ type: getErrorType(prettyError),
604
+ code: prettyError.code,
605
+ name: prettyError.name
606
+ }
564
607
  };
565
608
  };
566
- const getHelpfulChildProcessError = (stdout, stderr) => {
567
- if (isUnhelpfulNativeModuleError(stderr)) {
568
- return getNativeModuleErrorMessage(stderr);
569
- }
570
- if (isModulesSyntaxError(stderr)) {
571
- return getModuleSyntaxError();
572
- }
573
- if (isModuleNotFoundError(stderr)) {
574
- return getModuleNotFoundError(stderr);
575
- }
576
- const lines = splitLines(stderr);
577
- const {
578
- actualMessage,
579
- rest
580
- } = getDetails(lines);
609
+ const create$1$1 = (message, error) => {
581
610
  return {
582
- message: `${actualMessage}`,
583
- code: '',
584
- stack: rest
611
+ jsonrpc: Two,
612
+ id: message.id,
613
+ error
585
614
  };
586
615
  };
587
- const normalizeLine$1 = line => {
588
- if (line.startsWith('Error: ')) {
589
- return line.slice('Error: '.length);
590
- }
591
- if (line.startsWith('VError: ')) {
592
- return line.slice('VError: '.length);
593
- }
594
- return line;
595
- };
596
- const getCombinedMessage$1 = (error, message) => {
597
- const stringifiedError = normalizeLine$1(`${error}`);
598
- if (message) {
599
- return `${message}: ${stringifiedError}`;
600
- }
601
- return stringifiedError;
616
+ const getErrorResponse = (message, error, preparePrettyError, logError) => {
617
+ const prettyError = preparePrettyError(error);
618
+ logError(error, prettyError);
619
+ const errorProperty = getErrorProperty(error, prettyError);
620
+ return create$1$1(message, errorProperty);
602
621
  };
603
- const NewLine$2 = '\n';
604
- const getNewLineIndex$1 = (string, startIndex = undefined) => {
605
- return string.indexOf(NewLine$2, startIndex);
622
+ const create$5 = (message, result) => {
623
+ return {
624
+ jsonrpc: Two,
625
+ id: message.id,
626
+ result: result ?? null
627
+ };
606
628
  };
607
- const mergeStacks$1 = (parent, child) => {
608
- if (!child) {
609
- return parent;
610
- }
611
- const parentNewLineIndex = getNewLineIndex$1(parent);
612
- const childNewLineIndex = getNewLineIndex$1(child);
613
- if (childNewLineIndex === -1) {
614
- return parent;
615
- }
616
- const parentFirstLine = parent.slice(0, parentNewLineIndex);
617
- const childRest = child.slice(childNewLineIndex);
618
- const childFirstLine = normalizeLine$1(child.slice(0, childNewLineIndex));
619
- if (parentFirstLine.includes(childFirstLine)) {
620
- return parentFirstLine + childRest;
621
- }
622
- return child;
629
+ const getSuccessResponse = (message, result) => {
630
+ const resultProperty = result ?? null;
631
+ return create$5(message, resultProperty);
623
632
  };
624
- let VError$1 = class VError extends Error {
625
- constructor(error, message) {
626
- const combinedMessage = getCombinedMessage$1(error, message);
627
- super(combinedMessage);
628
- this.name = 'VError';
629
- if (error instanceof Error) {
630
- this.stack = mergeStacks$1(this.stack, error.stack);
631
- }
632
- if (error.codeFrame) {
633
- // @ts-ignore
634
- this.codeFrame = error.codeFrame;
635
- }
636
- if (error.code) {
637
- // @ts-ignore
638
- this.code = error.code;
639
- }
633
+ const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
634
+ try {
635
+ const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
636
+ return getSuccessResponse(message, result);
637
+ } catch (error) {
638
+ return getErrorResponse(message, error, preparePrettyError, logError);
640
639
  }
641
640
  };
642
- class IpcError extends VError$1 {
643
- // @ts-ignore
644
- constructor(betterMessage, stdout = '', stderr = '') {
645
- if (stdout || stderr) {
646
- // @ts-ignore
647
- const {
648
- message,
649
- code,
650
- stack
651
- } = getHelpfulChildProcessError(stdout, stderr);
652
- const cause = new Error(message);
653
- // @ts-ignore
654
- cause.code = code;
655
- cause.stack = stack;
656
- super(cause, betterMessage);
657
- } else {
658
- super(betterMessage);
659
- }
660
- // @ts-ignore
661
- this.name = 'IpcError';
662
- // @ts-ignore
663
- this.stdout = stdout;
664
- // @ts-ignore
665
- this.stderr = stderr;
641
+ const defaultPreparePrettyError = error => {
642
+ return error;
643
+ };
644
+ const defaultLogError = () => {
645
+ // ignore
646
+ };
647
+ const defaultRequiresSocket = () => {
648
+ return false;
649
+ };
650
+ const defaultResolve = resolve;
651
+
652
+ // TODO maybe remove this in v6 or v7, only accept options object to simplify the code
653
+ const normalizeParams = args => {
654
+ if (args.length === 1) {
655
+ const options = args[0];
656
+ return {
657
+ ipc: options.ipc,
658
+ message: options.message,
659
+ execute: options.execute,
660
+ resolve: options.resolve || defaultResolve,
661
+ preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
662
+ logError: options.logError || defaultLogError,
663
+ requiresSocket: options.requiresSocket || defaultRequiresSocket
664
+ };
666
665
  }
667
- }
668
- const withResolvers = () => {
669
- let _resolve;
670
- const promise = new Promise(resolve => {
671
- _resolve = resolve;
672
- });
673
666
  return {
674
- resolve: _resolve,
675
- promise
667
+ ipc: args[0],
668
+ message: args[1],
669
+ execute: args[2],
670
+ resolve: args[3],
671
+ preparePrettyError: args[4],
672
+ logError: args[5],
673
+ requiresSocket: args[6]
676
674
  };
677
675
  };
678
- const waitForFirstMessage = async port => {
676
+ const handleJsonRpcMessage = async (...args) => {
677
+ const options = normalizeParams(args);
679
678
  const {
679
+ message,
680
+ ipc,
681
+ execute,
680
682
  resolve,
681
- promise
682
- } = withResolvers();
683
- port.addEventListener('message', resolve, {
684
- once: true
685
- });
686
- const event = await promise;
687
- // @ts-ignore
688
- return event.data;
689
- };
690
- const listen$1$1 = async () => {
691
- const parentIpcRaw = listen$2();
692
- signal$2(parentIpcRaw);
693
- const parentIpc = wrap$5(parentIpcRaw);
694
- const firstMessage = await waitForFirstMessage(parentIpc);
695
- if (firstMessage.method !== 'initialize') {
696
- throw new IpcError('unexpected first message');
697
- }
698
- const type = firstMessage.params[0];
699
- if (type === 'message-port') {
700
- parentIpc.send({
701
- jsonrpc: '2.0',
702
- id: firstMessage.id,
703
- result: null
704
- });
705
- parentIpc.dispose();
706
- const port = firstMessage.params[1];
707
- return port;
708
- }
709
- return globalThis;
710
- };
711
- class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
712
- constructor(port) {
713
- super(port);
714
- }
715
- getData(event) {
716
- return getData$1(event);
717
- }
718
- send(message) {
719
- this._rawIpc.postMessage(message);
720
- }
721
- sendAndTransfer(message) {
722
- const transfer = getTransferrables(message);
723
- this._rawIpc.postMessage(message, transfer);
724
- }
725
- dispose() {
726
- if (this._rawIpc.close) {
727
- this._rawIpc.close();
683
+ preparePrettyError,
684
+ logError,
685
+ requiresSocket
686
+ } = options;
687
+ if ('id' in message) {
688
+ if ('method' in message) {
689
+ const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
690
+ try {
691
+ ipc.send(response);
692
+ } catch (error) {
693
+ const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
694
+ ipc.send(errorResponse);
695
+ }
696
+ return;
728
697
  }
698
+ resolve(message.id, message);
699
+ return;
729
700
  }
730
- onClose(callback) {
731
- // ignore
701
+ if ('method' in message) {
702
+ await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
703
+ return;
732
704
  }
733
- onMessage(callback) {
734
- this._rawIpc.addEventListener('message', callback);
735
- this._rawIpc.start();
705
+ throw new JsonRpcError('unexpected message');
706
+ };
707
+ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
708
+ const {
709
+ message,
710
+ promise
711
+ } = create$2$1(method, params);
712
+ if (useSendAndTransfer && ipc.sendAndTransfer) {
713
+ ipc.sendAndTransfer(message);
714
+ } else {
715
+ ipc.send(message);
736
716
  }
737
- }
738
- const wrap$4 = port => {
739
- return new IpcChildWithModuleWorkerAndMessagePort(port);
717
+ const responseMessage = await promise;
718
+ return unwrapJsonRpcResult(responseMessage);
740
719
  };
741
- const IpcChildWithModuleWorkerAndMessagePort$1 = {
742
- __proto__: null,
743
- listen: listen$1$1,
744
- wrap: wrap$4
720
+ const send = (transport, method, ...params) => {
721
+ const message = create$4(method, params);
722
+ transport.send(message);
723
+ };
724
+ const invoke$4 = (ipc, method, ...params) => {
725
+ return invokeHelper(ipc, method, params, false);
726
+ };
727
+ const invokeAndTransfer$3 = (ipc, method, ...params) => {
728
+ return invokeHelper(ipc, method, params, true);
729
+ };
730
+
731
+ const commands = Object.create(null);
732
+ const register$4 = commandMap => {
733
+ Object.assign(commands, commandMap);
734
+ };
735
+ const getCommand = key => {
736
+ return commands[key];
737
+ };
738
+ const execute = (command, ...args) => {
739
+ const fn = getCommand(command);
740
+ if (!fn) {
741
+ throw new Error(`command not found ${command}`);
742
+ }
743
+ return fn(...args);
745
744
  };
746
745
 
747
746
  const createRpc = ipc => {
@@ -771,32 +770,38 @@ const logError = () => {
771
770
  // handled by renderer worker
772
771
  };
773
772
  const handleMessage = event => {
774
- return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket);
773
+ const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
774
+ return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, actualRequiresSocket);
775
775
  };
776
776
  const handleIpc = ipc => {
777
- ipc.addEventListener('message', handleMessage);
777
+ if ('addEventListener' in ipc) {
778
+ ipc.addEventListener('message', handleMessage);
779
+ } else if ('on' in ipc) {
780
+ // deprecated
781
+ ipc.on('message', handleMessage);
782
+ }
778
783
  };
779
-
780
- // @ts-ignore
781
- const listen$1 = async () => {
782
- const module = IpcChildWithModuleWorkerAndMessagePort$1;
783
- const rawIpc = await module.listen();
784
+ const listen$1 = async (module, options) => {
785
+ const rawIpc = await module.listen(options);
786
+ if (module.signal) {
787
+ module.signal(rawIpc);
788
+ }
784
789
  const ipc = module.wrap(rawIpc);
785
790
  return ipc;
786
791
  };
787
- const create$1$1 = async ({
792
+ const create$2 = async ({
788
793
  commandMap
789
794
  }) => {
790
795
  // TODO create a commandMap per rpc instance
791
796
  register$4(commandMap);
792
- const ipc = await listen$1();
797
+ const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
793
798
  handleIpc(ipc);
794
799
  const rpc = createRpc(ipc);
795
800
  return rpc;
796
801
  };
797
802
  const WebWorkerRpcClient = {
798
803
  __proto__: null,
799
- create: create$1$1
804
+ create: create$2
800
805
  };
801
806
 
802
807
  const state$1 = {
@@ -804,12 +809,10 @@ const state$1 = {
804
809
  };
805
810
  const invoke$3 = (method, ...params) => {
806
811
  const rpc = state$1.rpc;
807
- // @ts-ignore
808
812
  return rpc.invoke(method, ...params);
809
813
  };
810
814
  const invokeAndTransfer$2 = (method, ...params) => {
811
815
  const rpc = state$1.rpc;
812
- // @ts-ignore
813
816
  return rpc.invokeAndTransfer(method, ...params);
814
817
  };
815
818
  const setRpc = rpc => {
@@ -1015,62 +1018,6 @@ const getWebView = (webViews, webViewId) => {
1015
1018
  return undefined;
1016
1019
  };
1017
1020
 
1018
- const normalizeLine = line => {
1019
- if (line.startsWith('Error: ')) {
1020
- return line.slice('Error: '.length);
1021
- }
1022
- if (line.startsWith('VError: ')) {
1023
- return line.slice('VError: '.length);
1024
- }
1025
- return line;
1026
- };
1027
- const getCombinedMessage = (error, message) => {
1028
- const stringifiedError = normalizeLine(`${error}`);
1029
- if (message) {
1030
- return `${message}: ${stringifiedError}`;
1031
- }
1032
- return stringifiedError;
1033
- };
1034
- const NewLine = '\n';
1035
- const getNewLineIndex = (string, startIndex = undefined) => {
1036
- return string.indexOf(NewLine, startIndex);
1037
- };
1038
- const mergeStacks = (parent, child) => {
1039
- if (!child) {
1040
- return parent;
1041
- }
1042
- const parentNewLineIndex = getNewLineIndex(parent);
1043
- const childNewLineIndex = getNewLineIndex(child);
1044
- if (childNewLineIndex === -1) {
1045
- return parent;
1046
- }
1047
- const parentFirstLine = parent.slice(0, parentNewLineIndex);
1048
- const childRest = child.slice(childNewLineIndex);
1049
- const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
1050
- if (parentFirstLine.includes(childFirstLine)) {
1051
- return parentFirstLine + childRest;
1052
- }
1053
- return child;
1054
- };
1055
- class VError extends Error {
1056
- constructor(error, message) {
1057
- const combinedMessage = getCombinedMessage(error, message);
1058
- super(combinedMessage);
1059
- this.name = 'VError';
1060
- if (error instanceof Error) {
1061
- this.stack = mergeStacks(this.stack, error.stack);
1062
- }
1063
- if (error.codeFrame) {
1064
- // @ts-ignore
1065
- this.codeFrame = error.codeFrame;
1066
- }
1067
- if (error.code) {
1068
- // @ts-ignore
1069
- this.code = error.code;
1070
- }
1071
- }
1072
- }
1073
-
1074
1021
  const getIframeSrc = (webViews, webViewId, webViewPort, root, isGitpod, locationProtocol, locationHost, locationOrigin, platform, assetDir) => {
1075
1022
  try {
1076
1023
  const webView = getWebView(webViews, webViewId);
@@ -1169,6 +1116,11 @@ const getIframeSandbox = (webView, platform) => {
1169
1116
  return [AllowScripts, AllowSameOrigin, ...extensionSandbox];
1170
1117
  };
1171
1118
 
1119
+ const getIframePermissionPolicy = webView => {
1120
+ const extensionAllow = webView.allow || [];
1121
+ return extensionAllow;
1122
+ };
1123
+
1172
1124
  const state = {
1173
1125
  id: 0
1174
1126
  };
@@ -1304,6 +1256,8 @@ const create2 = async ({
1304
1256
 
1305
1257
  const csp = getWebViewCsp(webView);
1306
1258
  const sandbox = getIframeSandbox(webView, platform);
1259
+ const permissionPolicy = getIframePermissionPolicy(webView);
1260
+ const permissionPolicyString = permissionPolicy.join('; ');
1307
1261
  const iframeCsp = platform === Web ? csp : '';
1308
1262
  const credentialless = true;
1309
1263
  await invoke$3('ExtensionHostManagement.activateByEvent', `onWebView:${webViewId}`);
@@ -1313,7 +1267,7 @@ const create2 = async ({
1313
1267
  } = getPortTuple();
1314
1268
  const portId = create$1();
1315
1269
  await register(previewServerId, webViewPort, frameAncestors, webViewRoot, csp, iframeContent);
1316
- await invoke$1('WebView.create', id, iframeSrc, sandbox, iframeCsp, credentialless);
1270
+ await invoke$1('WebView.create', id, iframeSrc, sandbox, iframeCsp, credentialless, permissionPolicyString);
1317
1271
  await invoke$1('WebView.load', id);
1318
1272
  const origin = getWebViewOrigin(webViewPort, platform);
1319
1273
  const portType = '';