@lvce-editor/embeds-process 4.1.0 → 4.4.0

package/dist/embedsProcessMain.js

@@ -7,65 +7,15 @@ const add = (id, ipc) => {
 const get$2 = id => {
   return ipcMap[id];
 };
-const remove$1 = id => {
+const remove$2 = id => {
   delete ipcMap[id];
 };
 const getAll = () => {
   return Object.entries(ipcMap);
 };
 
-const rpcs = Object.create(null);
-const set$7 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$1 = id => {
-  return rpcs[id];
-};
-
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
-const create$6 = rpcId => {
-  return {
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get$1(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get$1(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    set(rpc) {
-      set$7(rpcId, rpc);
-    }
-  };
-};
-const MainProcess$1 = -5;
-const SharedProcess$1 = 1;
-const {
-  invoke: invoke$3,
-  set: set$3
-} = create$6(MainProcess$1);
-const MainProcess$2 = {
-  __proto__: null,
-  invoke: invoke$3,
-  set: set$3
-};
-const {
-  set: set$4
-} = create$6(SharedProcess$1);
-const SharedProcess$2 = {
-  __proto__: null,
-  set: set$4
-};
-
-const {
-  invoke: invoke$1,
-  set: set$2
-} = MainProcess$2;
+const MainProcess$2 = -5;
+const SharedProcess$2 = 1492;
 
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
@@ -123,175 +73,55 @@ class VError extends Error {
   }
 }
 
-const dispose = async id => {
-  try {
-    await invoke$1('ElectronWebContents.dispose', id);
-  } catch (error) {
-    throw new VError(error, `Failed to dispose webcontents`);
-  }
-};
-const callFunction = (webContentsId, method, ...params) => {
-  return invoke$1(`ElectronWebContents.callFunction`, webContentsId, method, ...params);
-};
-const focus = webContentsId => {
-  return callFunction(webContentsId, 'focus');
-};
-const openDevtools = webContentsId => {
-  return callFunction(webContentsId, 'openDevTools');
-};
-const reload = webContentsId => {
-  return callFunction(webContentsId, 'reload');
-};
-const forward = webContentsId => {
-  return callFunction(webContentsId, 'goForward');
-};
-const backward = webContentsId => {
-  return callFunction(webContentsId, 'goBack');
-};
-const inspectElement = (webContentsId, x, y) => {
-  return callFunction(webContentsId, `inspectElement`, x, y);
-};
-
 class AssertionError extends Error {
   constructor(message) {
     super(message);
     this.name = 'AssertionError';
   }
 }
+const Object$1 = 1;
+const Number$1 = 2;
+const Array$1 = 3;
+const String = 4;
+const Boolean = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
 const getType = value => {
   switch (typeof value) {
     case 'number':
-      return 'number';
+      return Number$1;
     case 'function':
-      return 'function';
+      return Function;
     case 'string':
-      return 'string';
+      return String;
     case 'object':
       if (value === null) {
-        return 'null';
+        return Null;
       }
       if (Array.isArray(value)) {
-        return 'array';
+        return Array$1;
       }
-      return 'object';
+      return Object$1;
     case 'boolean':
-      return 'boolean';
+      return Boolean;
     default:
-      return 'unknown';
+      return Unknown;
   }
 };
 const object = value => {
   const type = getType(value);
-  if (type !== 'object') {
+  if (type !== Object$1) {
     throw new AssertionError('expected value to be of type object');
   }
 };
 const number = value => {
   const type = getType(value);
-  if (type !== 'number') {
+  if (type !== Number$1) {
     throw new AssertionError('expected value to be of type number');
   }
 };
 
-const createWebContentsView = async (ipcId, restoreId, fallthroughKeyBindings) => {
-  number(restoreId);
-  // TODO race condition: ipc can be disposed while webcontents are being created
-  const webContentsId = await invoke$1('ElectronWebContentsView.createWebContentsView', restoreId);
-  add(webContentsId, ipcId);
-  // TODO get window id from renderer worker
-  await invoke$1('ElectronWebContentsView.attachEventListeners', webContentsId);
-  await invoke$1('ElectronWebContentsViewFunctions.setBackgroundColor', webContentsId, 'white');
-  return webContentsId;
-};
-const disposeWebContentsView = async id => {
-  await invoke$1('ElectronWebContentsView.disposeWebContentsView', id);
-  await dispose(id);
-};
-const resizeWebContentsView = async (id, ...args) => {
-  return invoke$1('ElectronWebContentsViewFunctions.resizeBrowserView', id, ...args);
-};
-const setIframeSrc = async (id, ...args) => {
-  return invoke$1('ElectronWebContentsViewFunctions.setIframeSrc', id, ...args);
-};
-const setIframeSrcFallback = async (id, ...args) => {
-  return invoke$1('ElectronWebContentsViewFunctions.setIframeSrcFallback', id, ...args);
-};
-const setFallthroughKeyBindings = async (id, ...args) => {
-  return invoke$1('ElectronWebContentsViewFunctions.setFallthroughKeyBindings', id, ...args);
-};
-const getStats = async (id, ...args) => {
-  return invoke$1('ElectronWebContentsViewFunctions.getStats', id, ...args);
-};
-const getDomTree = async id => {
-  // @ts-ignore
-  return invoke$1('ElectronWebContentsViewFunctions.getDomTree', id);
-};
-const insertCss = async (id, css) => {
-  // @ts-ignore
-  return invoke$1('ElectronWebContentsViewFunctions.insertCss', id, css);
-};
-const insertJavaScript = async (id, css) => {
-  // @ts-ignore
-  return invoke$1('ElectronWebContentsViewFunctions.insertJavaScript', id, css);
-};
-const show = async (id, ...args) => {
-  return invoke$1('ElectronWebContentsViewFunctions.show', id, ...args);
-};
-const forwardIpcEvent = key => (id, ...args) => {
-  const ipc = get$2(id);
-  if (!ipc) {
-    return;
-  }
-  ipc.send(key, id, ...args);
-};
-const handleDidNavigate = forwardIpcEvent('ElectronWebContentsView.handleDidNavigate');
-const handleTitleUpdated = forwardIpcEvent('ElectronWebContentsView.handleTitleUpdated');
-const handleWillNavigate = forwardIpcEvent('ElectronWebContentsView.handleWillNavigate');
-const handleContextMenu = forwardIpcEvent('ElectronWebContentsView.handleContextMenu');
-const handleKeyBinding = forwardIpcEvent('ElectronWebContentsView.handleKeyBinding');
-const handleBrowserViewDestroyed = (id, ...args) => {
-  // TODO send to embeds worker?
-};
-
-const applyIncomingIpcResponse = async (target, response, ipcId) => {
-  switch (response.type) {
-    case 'handle':
-      break;
-    default:
-      throw new Error('unexpected response');
-  }
-};
-
-const handleIncomingIpcMessagePort = async (module, handle, message) => {
-  const target = await module.targetMessagePort(handle, message);
-  const response = module.upgradeMessagePort(handle, message);
-  return {
-    target,
-    response
-  };
-};
-
-const commandMapRef = {};
-
-const getIdsToDispose = ipc => {
-  const entries = getAll();
-  const toDispose = [];
-  for (const [id, value] of entries) {
-    if (value === ipc) {
-      toDispose.push(Number.parseInt(id));
-    }
-  }
-  return toDispose;
-};
-const handleIpcClosed = async event => {
-  const idsToDispose = getIdsToDispose(event.target);
-  for (const id of idsToDispose) {
-    remove$1(id);
-    await disposeWebContentsView(id);
-  }
-  // SharedProcessIpc.send('HandleMessagePortForEmbedsProcess.handleEmbedsProcessIpcClosed')
-};
-
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -469,8 +299,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -493,14 +323,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -519,8 +349,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -530,8 +360,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -614,7 +444,7 @@ const listen$a = () => {
     parentPort
   } = process;
   if (!parentPort) {
-    throw new Error('parent port must be defined');
+    throw new IpcError('parent port must be defined');
   }
   return parentPort;
 };
@@ -672,7 +502,7 @@ const getTransferrablesNode = value => {
 };
 const listen$5 = async () => {
   if (!process.send) {
-    throw new Error('process.send must be defined');
+    throw new IpcError('process.send must be defined');
   }
   return process;
 };
@@ -714,7 +544,7 @@ const listen$3 = async () => {
     parentPort
   } = await import('node:worker_threads');
   if (!parentPort) {
-    throw new IpcError('parentPort is required');
+    throw new IpcError('parentPort is required for node worker threads ipc');
   }
   return parentPort;
 };
@@ -769,8 +599,8 @@ const removeListener = (emitter, type, callback) => {
 };
 const getFirstEvent = (eventEmitter, eventMap) => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   const listenerMap = Object.create(null);
   const cleanup = value => {
@@ -782,8 +612,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   for (const [event, type] of Object.entries(eventMap)) {
     const listener = event => {
       cleanup({
-        type,
-        event
+        event,
+        type
       });
     };
     addListener(eventEmitter, event, listener);
@@ -799,28 +629,28 @@ const getFirstWebSocketEvent = async webSocket => {
     WebSocket
   } = await import('ws');
   switch (webSocket.readyState) {
-    case WebSocket.OPEN:
+    case WebSocket.CLOSED:
       return {
-        type: Open,
-        event: undefined
+        event: undefined,
+        type: Close
       };
-    case WebSocket.CLOSED:
+    case WebSocket.OPEN:
       return {
-        type: Close,
-        event: undefined
+        event: undefined,
+        type: Open
       };
   }
   // @ts-ignore
   const {
-    type,
-    event
+    event,
+    type
   } = await getFirstEvent(webSocket, {
-    open: Open,
-    close: Close
+    close: Close,
+    open: Open
   });
   return {
-    type,
-    event
+    event,
+    type
   };
 };
 
@@ -849,11 +679,9 @@ const handleUpgrade$1 = async (...args) => {
   // @ts-ignore
   return module.handleUpgrade(...args);
 };
-
-// @ts-ignore
 const listen$1$1 = async ({
-  request,
-  handle
+  handle,
+  request
 }) => {
   if (!request) {
     throw new IpcError('request must be defined');
@@ -871,18 +699,21 @@ const listen$1$1 = async ({
 const signal$4 = webSocket => {
   webSocket.resume();
 };
-
-// @ts-ignore
 const wrap$9 = webSocket => {
   return {
-    webSocket,
-    /**
-     * @type {any}
-     */
-    wrappedListener: undefined,
+    dispose() {
+      this.webSocket.close();
+    },
+    // @ts-ignore
+    off(event, listener) {
+      this.webSocket.off(event, listener);
+    },
     // @ts-ignore
     on(event, listener) {
       switch (event) {
+        case 'close':
+          webSocket.on('close', listener);
+          break;
         case 'message':
           // @ts-ignore
           const wrappedListener = message => {
@@ -895,28 +726,23 @@ const wrap$9 = webSocket => {
           };
           webSocket.on('message', wrappedListener);
           break;
-        case 'close':
-          webSocket.on('close', listener);
-          break;
         default:
           throw new Error('unknown event listener type');
       }
     },
     // @ts-ignore
-    off(event, listener) {
-      this.webSocket.off(event, listener);
-    },
-    // @ts-ignore
     send(message) {
       const stringifiedMessage = serialize(message);
       this.webSocket.send(stringifiedMessage);
     },
-    dispose() {
-      this.webSocket.close();
-    },
     start() {
       throw new Error('start method is deprecated');
-    }
+    },
+    webSocket,
+    /**
+     * @type {any}
+     */
+    wrappedListener: undefined
   };
 };
 const IpcChildWithWebSocket = {
@@ -926,56 +752,14 @@ const IpcChildWithWebSocket = {
   wrap: wrap$9
 };
 
-const Two = '2.0';
-const create$4$1 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
+const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const set$1 = (id, fn) => {
-  callbacks[id] = fn;
-};
-const get = id => {
+const get$1 = id => {
   return callbacks[id];
 };
-const remove = id => {
+const remove$1 = id => {
   delete callbacks[id];
 };
-let id = 0;
-const create$3 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$1(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
@@ -1027,6 +811,17 @@ const constructError = (message, type, name) => {
   }
   return new ErrorConstructor(message);
 };
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
+const getCurrentStack = () => {
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
+  return currentStack;
+};
 const getNewLineIndex = (string, startIndex = undefined) => {
   return string.indexOf(NewLine, startIndex);
 };
@@ -1037,19 +832,16 @@ const getParentStack = error => {
   }
   return parentStack;
 };
-const joinLines = lines => {
-  return lines.join(NewLine);
-};
 const MethodNotFound = -32601;
 const Custom = -32001;
-const splitLines = lines => {
-  return lines.split(NewLine);
-};
 const restoreJsonRpcError = error => {
+  const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
+    if (typeof error.stack === 'string') {
+      error.stack = error.stack + NewLine + currentStack;
+    }
     return error;
   }
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(1));
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
@@ -1111,14 +903,14 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get(id);
+  const fn = get$1(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
     return;
   }
   fn(response);
-  remove(id);
+  remove$1(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -1130,6 +922,17 @@ const getErrorType = prettyError => {
   }
   return undefined;
 };
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
+};
+const getStack = prettyError => {
+  const stackString = prettyError.stack || '';
+  const newLineIndex = stackString.indexOf('\n');
+  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
+    return stackString.slice(newLineIndex + 1);
+  }
+  return stackString;
+};
 const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
@@ -1142,7 +945,7 @@ const getErrorProperty = (error, prettyError) => {
     code: Custom,
     message: prettyError.message,
     data: {
-      stack: prettyError.stack,
+      stack: getStack(prettyError),
       codeFrame: prettyError.codeFrame,
       type: getErrorType(prettyError),
       code: prettyError.code,
@@ -1150,36 +953,51 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1 = (message, error) => {
+const create$1 = (id, error) => {
   return {
-    jsonrpc: Two,
-    id: message.id,
+    jsonrpc: Two$1,
+    id,
     error
   };
 };
-const getErrorResponse = (message, error, preparePrettyError, logError) => {
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(message, errorProperty);
+  return create$1(id, errorProperty);
 };
-const create = (message, result) => {
+const create$2 = (message, result) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id: message.id,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create(message, resultProperty);
+  return create$2(message, resultProperty);
 };
-const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
-  try {
-    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
+const getErrorResponseSimple = (id, error) => {
+  return {
+    jsonrpc: Two$1,
+    id,
+    error: {
+      code: Custom,
+      // @ts-ignore
+      message: error.message,
+      data: error
+    }
+  };
+};
+const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+  try {
+    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
     return getSuccessResponse(message, result);
   } catch (error) {
-    return getErrorResponse(message, error, preparePrettyError, logError);
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
   }
 };
 const defaultPreparePrettyError = error => {
@@ -1234,7 +1052,7 @@ const handleJsonRpcMessage = async (...args) => {
       try {
         ipc.send(response);
       } catch (error) {
-        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
         ipc.send(errorResponse);
       }
       return;
@@ -1248,30 +1066,13 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
-};
-const invoke = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
 const commands = Object.create(null);
 const register = commandMap => {
   Object.assign(commands, commandMap);
@@ -1282,29 +1083,92 @@ const getCommand = key => {
 const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new Error(`command not found ${command}`);
+    throw new CommandNotFoundError(command);
   }
   return fn(...args);
 };
 
+const Two = '2.0';
+const create$t = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$s = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$r = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$r();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$s(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$t(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -1321,7 +1185,7 @@ const logError = () => {
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
   const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
@@ -1339,7 +1203,7 @@ const listen$2 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$e = async ({
+const create$q = async ({
   commandMap,
   messagePort,
   requiresSocket
@@ -1358,9 +1222,9 @@ const create$e = async ({
 };
 const ElectronMessagePortRpcClient = {
   __proto__: null,
-  create: create$e
+  create: create$q
 };
-const create$d = async ({
+const create$p = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1372,9 +1236,9 @@ const create$d = async ({
 };
 const ElectronUtilityProcessRpcClient = {
   __proto__: null,
-  create: create$d
+  create: create$p
 };
-const create$7 = async ({
+const create$a = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1386,19 +1250,19 @@ const create$7 = async ({
 };
 const NodeForkedProcessRpcClient = {
   __proto__: null,
-  create: create$7
+  create: create$a
 };
-const create$5 = async ({
+const create$8 = async ({
   commandMap,
-  request,
   handle,
+  request,
   requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
   const ipc = await listen$2(IpcChildWithWebSocket, {
-    request,
-    handle
+    handle,
+    request
   });
   if (requiresSocket) {
     ipc.requiresSocket = requiresSocket;
@@ -1409,9 +1273,9 @@ const create$5 = async ({
 };
 const NodeWebSocketRpcClient = {
   __proto__: null,
-  create: create$5
+  create: create$8
 };
-const create$4 = async ({
+const create$7 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1423,7 +1287,227 @@ const create$4 = async ({
 };
 const NodeWorkerRpcClient = {
   __proto__: null,
-  create: create$4
+  create: create$7
+};
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
+  };
+  return mockRpc;
+};
+
+const rpcs = Object.create(null);
+const set$4 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get = id => {
+  return rpcs[id];
+};
+const remove = id => {
+  delete rpcs[id];
+};
+
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+const create = rpcId => {
+  return {
+    async dispose() {
+      const rpc = get(rpcId);
+      await rpc.dispose();
+    },
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$4(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
+    set(rpc) {
+      set$4(rpcId, rpc);
+    }
+  };
+};
+
+const {
+  invoke: invoke$1,
+  set: set$3
+} = create(MainProcess$2);
+
+const MainProcess$1 = {
+  __proto__: null,
+  invoke: invoke$1,
+  set: set$3
+};
+
+const {
+  set: set$2
+} = create(SharedProcess$2);
+
+const SharedProcess$1 = {
+  __proto__: null,
+  set: set$2
+};
+
+const {
+  invoke,
+  set: set$1
+} = MainProcess$1;
+
+const dispose = async id => {
+  try {
+    await invoke('ElectronWebContents.dispose', id);
+  } catch (error) {
+    throw new VError(error, `Failed to dispose webcontents`);
+  }
+};
+const callFunction = (webContentsId, method, ...params) => {
+  return invoke(`ElectronWebContents.callFunction`, webContentsId, method, ...params);
+};
+const focus = webContentsId => {
+  return callFunction(webContentsId, 'focus');
+};
+const openDevtools = webContentsId => {
+  return callFunction(webContentsId, 'openDevTools');
+};
+const reload = webContentsId => {
+  return callFunction(webContentsId, 'reload');
+};
+const forward = webContentsId => {
+  return callFunction(webContentsId, 'goForward');
+};
+const backward = webContentsId => {
+  return callFunction(webContentsId, 'goBack');
+};
+const inspectElement = (webContentsId, x, y) => {
+  return callFunction(webContentsId, `inspectElement`, x, y);
+};
+
+const createWebContentsView = async (ipcId, restoreId, fallthroughKeyBindings) => {
+  number(restoreId);
+  // TODO race condition: ipc can be disposed while webcontents are being created
+  const webContentsId = await invoke('ElectronWebContentsView.createWebContentsView', restoreId);
+  add(webContentsId, ipcId);
+  // TODO get window id from renderer worker
+  await invoke('ElectronWebContentsView.attachEventListeners', webContentsId);
+  await invoke('ElectronWebContentsViewFunctions.setBackgroundColor', webContentsId, 'white');
+  return webContentsId;
+};
+const disposeWebContentsView = async id => {
+  await invoke('ElectronWebContentsView.disposeWebContentsView', id);
+  await dispose(id);
+};
+const resizeWebContentsView = async (id, ...args) => {
+  return invoke('ElectronWebContentsViewFunctions.resizeBrowserView', id, ...args);
+};
+const setIframeSrc = async (id, ...args) => {
+  return invoke('ElectronWebContentsViewFunctions.setIframeSrc', id, ...args);
+};
+const setIframeSrcFallback = async (id, ...args) => {
+  return invoke('ElectronWebContentsViewFunctions.setIframeSrcFallback', id, ...args);
+};
+const setFallthroughKeyBindings = async (id, ...args) => {
+  return invoke('ElectronWebContentsViewFunctions.setFallthroughKeyBindings', id, ...args);
+};
+const getStats = async (id, ...args) => {
+  return invoke('ElectronWebContentsViewFunctions.getStats', id, ...args);
+};
+const getDomTree = async id => {
+  // @ts-ignore
+  return invoke('ElectronWebContentsViewFunctions.getDomTree', id);
+};
+const insertCss = async (id, css) => {
+  // @ts-ignore
+  return invoke('ElectronWebContentsViewFunctions.insertCss', id, css);
+};
+const insertJavaScript = async (id, css) => {
+  // @ts-ignore
+  return invoke('ElectronWebContentsViewFunctions.insertJavaScript', id, css);
+};
+const show = async (id, ...args) => {
+  return invoke('ElectronWebContentsViewFunctions.show', id, ...args);
+};
+const forwardIpcEvent = key => (id, ...args) => {
+  const ipc = get$2(id);
+  if (!ipc) {
+    return;
+  }
+  ipc.send(key, id, ...args);
+};
+const handleDidNavigate = forwardIpcEvent('ElectronWebContentsView.handleDidNavigate');
+const handleTitleUpdated = forwardIpcEvent('ElectronWebContentsView.handleTitleUpdated');
+const handleWillNavigate = forwardIpcEvent('ElectronWebContentsView.handleWillNavigate');
+const handleContextMenu = forwardIpcEvent('ElectronWebContentsView.handleContextMenu');
+const handleKeyBinding = forwardIpcEvent('ElectronWebContentsView.handleKeyBinding');
+const handleBrowserViewDestroyed = (id, ...args) => {
+  // TODO send to embeds worker?
+};
+
+const applyIncomingIpcResponse = async (target, response, ipcId) => {
+  switch (response.type) {
+    case 'handle':
+      break;
+    default:
+      throw new Error('unexpected response');
+  }
+};
+
+const handleIncomingIpcMessagePort = async (module, handle, message) => {
+  const target = await module.targetMessagePort(handle, message);
+  const response = module.upgradeMessagePort(handle, message);
+  return {
+    response,
+    target
+  };
+};
+
+const commandMapRef = {};
+
+const getIdsToDispose = ipc => {
+  const entries = getAll();
+  const toDispose = [];
+  for (const [id, value] of entries) {
+    if (value === ipc) {
+      toDispose.push(Number.parseInt(id));
+    }
+  }
+  return toDispose;
+};
+const handleIpcClosed = async event => {
+  const idsToDispose = getIdsToDispose(event.target);
+  for (const id of idsToDispose) {
+    remove$2(id);
+    await disposeWebContentsView(id);
+  }
+  // SharedProcessIpc.send('HandleMessagePortForEmbedsProcess.handleEmbedsProcessIpcClosed')
 };
 
 const NodeWorker = 1;
@@ -1446,14 +1530,14 @@ const Auto = argv => {
 
 const getModule$1 = method => {
   switch (method) {
+    case ElectronMessagePort:
+      return ElectronMessagePortRpcClient.create;
+    case ElectronUtilityProcess:
+      return ElectronUtilityProcessRpcClient.create;
     case NodeForkedProcess:
       return NodeForkedProcessRpcClient.create;
     case NodeWorker:
       return NodeWorkerRpcClient.create;
-    case ElectronUtilityProcess:
-      return ElectronUtilityProcessRpcClient.create;
-    case ElectronMessagePort:
-      return ElectronMessagePortRpcClient.create;
     case WebSocket:
       return NodeWebSocketRpcClient.create;
     default:
@@ -1473,9 +1557,9 @@ const listen$1 = async ({
 const targetMessagePort$2 = async (messagePort, message) => {
   object(messagePort);
   const rpc = await listen$1({
-    method: ElectronMessagePort,
+    commandMap: commandMapRef,
     messagePort,
-    commandMap: commandMapRef
+    method: ElectronMessagePort
   });
   // @ts-ignore
   const {
@@ -1499,10 +1583,10 @@ const HandleIpcEmbedsWorker = {
 const targetMessagePort$1 = async (messagePort, message) => {
   object(messagePort);
   const rpc = await listen$1({
-    method: ElectronMessagePort,
-    messagePort
+    messagePort,
+    method: ElectronMessagePort
   });
-  set$2(rpc);
+  set$1(rpc);
   return rpc;
 };
 const upgradeMessagePort$1 = () => {
@@ -1519,13 +1603,13 @@ const HandleIpcMainProcess = {
 
 const {
   set
-} = SharedProcess$2;
+} = SharedProcess$1;
 
 const targetMessagePort = async (messagePort, message) => {
   object(messagePort);
   const rpc = await ElectronMessagePortRpcClient.create({
-    messagePort,
-    commandMap: commandMapRef
+    commandMap: commandMapRef,
+    messagePort
   });
   set(rpc);
   return rpc;
@@ -1545,20 +1629,22 @@ const HandleIpcSharedProcess = {
 const EmbedsWorker = 77;
 const MainProcess = -5;
 const SharedProcess = 1;
+const SharedProcessAlt = 1492;
 const EmbedsWorkerAlt = 208;
 
 const getModule = ipcId => {
   number(ipcId);
   switch (ipcId) {
-    case SharedProcess:
-      return HandleIpcSharedProcess;
-    // deprecated
     case EmbedsWorker:
     case EmbedsWorkerAlt:
       return HandleIpcEmbedsWorker;
     case MainProcess:
       return HandleIpcMainProcess;
     // deprecated
+    case SharedProcess:
+    case SharedProcessAlt:
+      return HandleIpcSharedProcess;
+    // deprecated
     default:
       throw new Error(`Embeds process encountered unexpected incoming ipc ${ipcId}`);
   }
@@ -1571,8 +1657,8 @@ const handleIncomingIpc = async (ipcId, handle, message) => {
   number(ipcId);
   const module = getModule(ipcId);
   const {
-    target,
-    response
+    response,
+    target
   } = await getIpcAndResponse(module, handle, message);
   await applyIncomingIpcResponse(target, response);
 };
@@ -1597,7 +1683,7 @@ const createMainProcessRpc = async port => {
 
 const initialize = async port => {
   const rpc = await createMainProcessRpc(port);
-  set$2(rpc);
+  set$1(rpc);
 };
 
 const commandMap = {
@@ -1631,8 +1717,8 @@ const commandMap = {
 const listen = async argv => {
   Object.assign(commandMapRef, commandMap);
   await listen$1({
-    method: Auto(argv),
-    commandMap: commandMap
+    commandMap: commandMap,
+    method: Auto(argv)
   });
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/embeds-process",
-  "version": "4.1.0",
+  "version": "4.4.0",
   "description": "Embeds Process",
   "keywords": [
     "Lvce Editor"