@lvce-editor/static-server 0.67.6 → 0.68.1

package/static/{fcae047 → a15686f}/packages/menu-worker/dist/menuWorkerMain.js

@@ -411,6 +411,100 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   listen: listen$6,
   wrap: wrap$e
 };
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        type,
+        event
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5$1 = async ({
+  messagePort,
+  isMessagePortOpen
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const {
+    type,
+    event
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError('Failed to wait for ipc message');
+  }
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$5$1,
+  signal: signal$1,
+  wrap: wrap$5
+};
 
 const Two = '2.0';
 const create$4 = (method, params) => {
@@ -421,7 +515,7 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$4 = (id, fn) => {
+const set$5 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$3 = id => {
@@ -431,16 +525,16 @@ const remove = id => {
   delete callbacks[id];
 };
 let id$a = 0;
-const create$3 = () => {
+const create$3$1 = () => {
   return ++id$a;
 };
 const registerPromise = () => {
-  const id = create$3();
+  const id = create$3$1();
   const {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$4(id, resolve);
+  set$5(id, resolve);
   return {
     id,
     promise
@@ -668,7 +762,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$5 = (message, result) => {
+const create$6 = (message, result) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -677,7 +771,7 @@ const create$5 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$5(message, resultProperty);
+  return create$6(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -781,11 +875,11 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const send = (transport, method, ...params) => {
+const send$1 = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-const invoke$3 = (ipc, method, ...params) => {
+const invoke$4 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer$1 = (ipc, method, ...params) => {
@@ -821,10 +915,10 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
+      send$1(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$3(ipc, method, ...params);
+      return invoke$4(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer$1(ipc, method, ...params);
@@ -865,6 +959,40 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
+const create$5 = async ({
+  commandMap,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    messagePort,
+    isMessagePortOpen: true
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+const create$3 = async ({
+  commandMap,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5({
+    commandMap,
+    messagePort: port2
+  });
+};
+const TransferMessagePortRpcParent = {
+  __proto__: null,
+  create: create$3
+};
 const create$2 = async ({
   commandMap
 }) => {
@@ -901,6 +1029,10 @@ const createMockRpc = ({
 
 const Text = 12;
 
+const Button = 'event.button';
+const ClientX = 'event.clientX';
+const ClientY = 'event.clientY';
+
 const Backspace$1 = 1;
 const Tab$1 = 2;
 const Enter$1 = 3;
@@ -1167,6 +1299,8 @@ const getKeyCodeString = keyCode => {
   }
 };
 
+const Script = 2;
+
 const CtrlCmd = 1 << 11 >>> 0;
 const Shift = 1 << 10 >>> 0;
 
@@ -1190,10 +1324,13 @@ const parseKey = rawKey => {
 };
 
 const DebugWorker = 55;
+const RendererProcess = 1670;
 const RendererWorker$1 = 1;
 
+const FocusSelector = 'Viewlet.focusSelector';
+
 const rpcs = Object.create(null);
-const set$3 = (id, rpc) => {
+const set$4 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$2 = id => {
@@ -1215,7 +1352,7 @@ const create$1 = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$3(rpcId, rpc);
+      set$4(rpcId, rpc);
     },
     async dispose() {
       const rpc = get$2(rpcId);
@@ -1224,6 +1361,10 @@ const create$1 = rpcId => {
   };
 };
 
+const {
+  invoke: invoke$3,
+  set: set$3} = create$1(RendererProcess);
+
 const {
   invoke: invoke$2,
   invokeAndTransfer,
@@ -1236,9 +1377,20 @@ const searchFileHtml = async uri => {
 const getFilePathElectron = async file => {
   return invoke$2('FileSystemHandle.getFilePathElectron', file);
 };
+/**
+ * @deprecated
+ */
 const showContextMenu = async (x, y, id, ...args) => {
   return invoke$2('ContextMenu.show', x, y, id, ...args);
 };
+const showContextMenu2 = async (uid, menuId, x, y, args) => {
+  number(uid);
+  number(menuId);
+  number(x);
+  number(y);
+  // @ts-ignore
+  await invoke$2('ContextMenu.show2', uid, menuId, x, y, args);
+};
 const getElectronVersion = async () => {
   return invoke$2('Process.getElectronVersion');
 };
@@ -1354,6 +1506,9 @@ const getKeyBindings$1 = async () => {
 const writeClipBoardText = async text => {
   await invoke$2('ClipBoard.writeText', /* text */text);
 };
+const readClipBoardText = async () => {
+  return invoke$2('ClipBoard.readText');
+};
 const writeClipBoardImage = async blob => {
   // @ts-ignore
   await invoke$2('ClipBoard.writeImage', /* text */blob);
@@ -1397,6 +1552,16 @@ const sendMessagePortToRendererProcess = async port => {
   // @ts-ignore
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
 };
+const sendMessagePortToTextMeasurementWorker = async port => {
+  const command = 'TextMeasurement.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
+};
+const sendMessagePortToSourceControlWorker = async port => {
+  const command = 'SourceControl.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker', port, command, 0);
+};
 const getPreference = async key => {
   return await invoke$2('Preferences.get', key);
 };
@@ -1468,7 +1633,7 @@ const openExtensionSearch = async () => {
 };
 const setExtensionsSearchValue = async searchValue => {
   // @ts-ignore
-  return invoke$2('Extensions.handleInput', searchValue);
+  return invoke$2('Extensions.handleInput', searchValue, Script);
 };
 const openExternal = async uri => {
   // @ts-ignore
@@ -1545,6 +1710,7 @@ const RendererWorker = {
   openUri,
   openUrl,
   openWidget,
+  readClipBoardText,
   readFile,
   registerMockRpc,
   registerWebViewInterceptor,
@@ -1561,7 +1727,9 @@ const RendererWorker = {
   sendMessagePortToMarkdownWorker,
   sendMessagePortToRendererProcess,
   sendMessagePortToSearchProcess,
+  sendMessagePortToSourceControlWorker,
   sendMessagePortToSyntaxHighlightingWorker,
+  sendMessagePortToTextMeasurementWorker,
   set: set$2,
   setAdditionalFocus,
   setColorTheme,
@@ -1570,6 +1738,7 @@ const RendererWorker = {
   setWebViewPort,
   setWorkspacePath,
   showContextMenu,
+  showContextMenu2,
   showErrorDialog,
   showMessageBox,
   showSaveFilePicker,
@@ -1579,6 +1748,122 @@ const RendererWorker = {
   writeClipBoardText
 };
 
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+// TODO lazyload menuEntries and use Command.execute (maybe)
+
+// TODO difference between focusing with mouse or keyboard
+// with mouse -> open submenu
+// with keyboard -> don't open submenu, only focus
+
+// TODO this code seems a bit too complicated, maybe it can be simplified
+
+const state$1 = {
+  menus: [],
+  latestTimeStamp: 0};
+const addMenuInternal = menu => {
+  if (state$1.menus.length > 5) {
+    throw new Error('too many menus');
+  }
+  state$1.menus.push(menu);
+  return menu;
+};
+const getCount = () => {
+  return state$1.menus.length;
+};
+const reset = () => {
+  state$1.menus = [];
+};
+const get$1 = index => {
+  return state$1.menus[index];
+};
+const set$1 = menus => {
+  state$1.menus = menus;
+};
+const getAll = () => {
+  return state$1.menus;
+};
+const setTimestamp = timestamp => {
+  state$1.latestTimeStamp = timestamp;
+};
+const getLatestTimestamp = () => {
+  return state$1.latestTimeStamp;
+};
+
+const closeSubMenu = async () => {
+  const menus = getAll();
+  const parentMenu = menus.at(-1);
+  // @ts-ignore
+  await invoke$3(/* Menu.hideSubMenu */7903, /* parentIndex */parentMenu.focusedIndex);
+};
+
+const Separator$1 = 1;
+const None = 0;
+const SubMenu = 4;
+const Checked = 2;
+const Unchecked = 3;
+const Disabled = 5;
+const RestoreFocus = 6;
+const Ignore = 7;
+
+// TODO lazyload menuEntries and use Command.execute (maybe)
+const CONTEXT_MENU_WIDTH$1 = 250;
+
+// TODO difference between focusing with mouse or keyboard
+// with mouse -> open submenu
+// with keyboard -> don't open submenu, only focus
+
+// TODO this code seems a bit too complicated, maybe it can be simplified
+
+// TODO handle printable letter and focus item that starts with that letter
+
+// TODO pageup / pagedown keys
+
+// TODO more tests
+
+const CONTEXT_MENU_ITEM_HEIGHT$1 = 26;
+const CONTEXT_MENU_SEPARATOR_HEIGHT$1 = 11;
+const CONTEXT_MENU_PADDING$1 = 8;
+const getMenuHeight$1 = items => {
+  let height = CONTEXT_MENU_PADDING$1;
+  for (const item of items) {
+    switch (item.flags) {
+      case Separator$1:
+        height += CONTEXT_MENU_SEPARATOR_HEIGHT$1;
+        break;
+      default:
+        height += CONTEXT_MENU_ITEM_HEIGHT$1;
+        break;
+    }
+  }
+  return height;
+};
+const getMenuBounds = (x, y, items) => {
+  const menuWidth = CONTEXT_MENU_WIDTH$1;
+  const menuHeight = getMenuHeight$1(items);
+  const layoutState = {
+    points: [0, 0]
+  };
+  const windowWidth = layoutState.points[0];
+  const windowHeight = layoutState.points[1];
+  // TODO maybe only send labels and keybindings to ui (id not needed on ui)
+  // TODO what about separators?
+
+  if (x + menuWidth > windowWidth) {
+    x -= menuWidth;
+    x = Math.max(x, 0);
+  }
+  if (y + menuHeight > windowHeight) {
+    y -= menuHeight;
+    y = Math.max(y, 0);
+  }
+  return {
+    x,
+    y,
+    width: menuWidth,
+    height: menuHeight
+  };
+};
+
 const matchesArgs = (a, b) => {
   if (!a && !b) {
     return true;
@@ -1615,7 +1900,7 @@ const invoke$1 = async (method, ...params) => {
   await invoke$2('WebView.compatRendererProcessInvoke', method, ...params);
 };
 
-const state$1 = {
+const state = {
   /**
    * @type {any}
    */
@@ -1698,19 +1983,10 @@ const Terminal$1 = 14;
 const TitleBar = 15;
 const View$1 = 16;
 
-const Separator$1 = 1;
-const None = 0;
-const SubMenu = 4;
-const Checked = 2;
-const Unchecked = 3;
-const Disabled = 5;
-const RestoreFocus = 6;
-const Ignore = 7;
-
 const menuEntrySeparator = {
   id: 'separator',
   label: '',
-  flags: Separator$1,
+  flags: Separator$2,
   command: ''
 };
 
@@ -2193,7 +2469,7 @@ const getMenuEntries2 = async (uid, menuId, ...args) => {
 };
 
 const addKeyBindings = menuEntries => {
-  const keyBindings = state$1.matchingKeyBindings;
+  const keyBindings = state.matchingKeyBindings;
   const newMenuEntries = [];
   for (const menuEntry of menuEntries) {
     const keyBinding = getCommandKeyBinding(keyBindings, menuEntry.command, menuEntry.args);
@@ -2449,72 +2725,56 @@ const getVisible = (items, focusedIndex, expanded, level) => {
   return visibleItems;
 };
 
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
-// TODO lazyload menuEntries and use Command.execute (maybe)
-
-// TODO difference between focusing with mouse or keyboard
-// with mouse -> open submenu
-// with keyboard -> don't open submenu, only focus
-
-// TODO this code seems a bit too complicated, maybe it can be simplified
-
-const state = {
-  menus: [],
-  latestTimeStamp: 0};
-const addMenuInternal = menu => {
-  if (state.menus.length > 5) {
-    throw new Error('too many menus');
-  }
-  state.menus.push(menu);
-  return menu;
-};
-const getCount = () => {
-  return state.menus.length;
-};
-const reset = () => {
-  state.menus = [];
-};
-const get$1 = index => {
-  return state.menus[index];
-};
-const set$1 = menus => {
-  state.menus = menus;
-};
-const getAll = () => {
-  return state.menus;
-};
-const setTimestamp = timestamp => {
-  state.latestTimeStamp = timestamp;
-};
-const getLatestTimestamp = () => {
-  return state.latestTimeStamp;
+const CONTEXT_MENU_WIDTH = 250;
+const getMenuWidth = () => {
+  return CONTEXT_MENU_WIDTH;
 };
 
 // TODO lazyload menuEntries and use Command.execute (maybe)
-const CONTEXT_MENU_ITEM_HEIGHT$2 = 26;
-const CONTEXT_MENU_SEPARATOR_HEIGHT$2 = 11;
-const CONTEXT_MENU_PADDING$2 = 8;
-const getMenuHeight$2 = items => {
-  let height = CONTEXT_MENU_PADDING$2;
+const CONTEXT_MENU_ITEM_HEIGHT = 26;
+const CONTEXT_MENU_SEPARATOR_HEIGHT = 11;
+const CONTEXT_MENU_PADDING = 8;
+const getMenuHeight = items => {
+  let height = CONTEXT_MENU_PADDING;
   for (const item of items) {
     switch (item.flags) {
       case Separator$1:
-        height += CONTEXT_MENU_SEPARATOR_HEIGHT$2;
+        height += CONTEXT_MENU_SEPARATOR_HEIGHT;
         break;
       default:
-        height += CONTEXT_MENU_ITEM_HEIGHT$2;
+        height += CONTEXT_MENU_ITEM_HEIGHT;
         break;
     }
   }
   return height;
 };
 
+const getMenuHideCommands = async (restoreFocus = true) => {
+  if (getCount() === 0) {
+    return {
+      newMenus: [],
+      commands: []
+    };
+  }
+  reset();
+  return {
+    commands: [/* Menu.hide */'Menu.hide', /* restoreFocus */restoreFocus],
+    newMenus: []
+  };
+};
+
+const hide = async (restoreFocus = true) => {
+  const {
+    commands
+  } = await getMenuHideCommands(restoreFocus);
+  if (commands.length > 0) {
+    // @ts-ignore
+    await invoke$3(...commands);
+  }
+};
+
 // TODO lazyload menuEntries and use Command.execute (maybe)
 const MENU_WIDTH = 150;
-const CONTEXT_MENU_WIDTH$1 = 250;
-const getMenuWidth = () => {
-  return CONTEXT_MENU_WIDTH$1;
-};
 
 // TODO difference between focusing with mouse or keyboard
 // with mouse -> open submenu
@@ -2526,50 +2786,9 @@ const getMenuWidth = () => {
 
 // TODO more tests
 
-const CONTEXT_MENU_ITEM_HEIGHT$1 = 26;
-const CONTEXT_MENU_SEPARATOR_HEIGHT$1 = 11;
-const CONTEXT_MENU_PADDING$1 = 8;
-const getMenuHeight$1 = items => {
-  let height = CONTEXT_MENU_PADDING$1;
-  for (const item of items) {
-    switch (item.flags) {
-      case Separator$1:
-        height += CONTEXT_MENU_SEPARATOR_HEIGHT$1;
-        break;
-      default:
-        height += CONTEXT_MENU_ITEM_HEIGHT$1;
-        break;
-    }
-  }
-  return height;
-};
-const getMenuBounds$1 = (x, y, items) => {
-  const menuWidth = CONTEXT_MENU_WIDTH$1;
-  const menuHeight = getMenuHeight$1(items);
-  const layoutState = {
-    points: [0, 0]
-  };
-  const windowWidth = layoutState.points[0];
-  const windowHeight = layoutState.points[1];
-  // TODO maybe only send labels and keybindings to ui (id not needed on ui)
-  // TODO what about separators?
-
-  if (x + menuWidth > windowWidth) {
-    x -= menuWidth;
-  }
-  if (y + menuHeight > windowHeight) {
-    y -= menuHeight;
-  }
-  return {
-    x,
-    y,
-    width: menuWidth,
-    height: menuHeight
-  };
-};
 const show$2 = async (x, y, id, mouseBlocking = false, ...args) => {
   const items = await getMenuEntriesWithKeyBindings(id, ...args);
-  const bounds = getMenuBounds$1(x, y, items);
+  const bounds = getMenuBounds(x, y, items);
   const menu = addMenuInternal({
     id,
     items,
@@ -2584,7 +2803,7 @@ const show$2 = async (x, y, id, mouseBlocking = false, ...args) => {
 };
 const show2$2 = async (uid, menuId, x, y, mouseBlocking = false, ...args) => {
   const items = await getMenuEntriesWithKeyBindings2(uid, menuId, ...args);
-  const bounds = getMenuBounds$1(x, y, items);
+  const bounds = getMenuBounds(x, y, items);
   const menu = addMenuInternal({
     id: menuId,
     items,
@@ -2597,17 +2816,10 @@ const show2$2 = async (uid, menuId, x, y, mouseBlocking = false, ...args) => {
   const dom = getMenuVirtualDom(visible).slice(1);
   await invoke$1(/* Menu.show */'Menu.showMenu', /* x */bounds.x, /* y */bounds.y, /* width */bounds.width, /* height */bounds.height, /* items */menu.items, /* level */menu.level, /* parentIndex */-1, /* dom */dom, /* mouseBlocking */mouseBlocking);
 };
-const hide$1 = async (restoreFocus = true) => {
-  if (getCount() === 0) {
-    return;
-  }
-  reset();
-  await invoke$1(/* Menu.hide */'Menu.hide', /* restoreFocus */restoreFocus);
-};
 
 const show$1 = async (x, y, id, ...args) => {
   // @ts-ignore
-  await hide$1();
+  await hide();
   // TODO handle error
   // TODO race condition
   await show$2(x, y, id, /* mouseBlocking */true, ...args);
@@ -2616,7 +2828,7 @@ const show$1 = async (x, y, id, ...args) => {
 };
 const show2$1 = async (uid, menuId, x, y, ...args) => {
   // @ts-ignore
-  await hide$1();
+  await hide();
   // TODO handle error
   // TODO race condition
   await show2$2(uid, menuId, x, y, /* mouseBlocking */true, ...args);
@@ -2645,7 +2857,7 @@ const show2 = async (uid, menuId, x, y, ...args) => {
   number(menuId);
   number(x);
   number(y);
-  const module = getModule();
+  const module = await getModule();
   // @ts-ignore
   return module.show2(uid, menuId, x, y, ...args);
 };
@@ -2727,10 +2939,7 @@ const focusIndex = async (menu, index) => {
   }
   const oldFocusedIndex = menu.focusedIndex;
   menu.focusedIndex = index;
-  return {
-    commands: [/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */index],
-    menus: getAll()
-  };
+  await invoke$3('Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */index);
 };
 
 const getCurrentMenu = () => {
@@ -2858,20 +3067,6 @@ const getKeyBindings = () => {
   }];
 };
 
-const getMenuHideCommands = async (restoreFocus = true) => {
-  if (getCount() === 0) {
-    return {
-      newMenus: [],
-      commands: []
-    };
-  }
-  reset();
-  return {
-    commands: [/* Menu.hide */'Menu.hide', /* restoreFocus */restoreFocus],
-    newMenus: []
-  };
-};
-
 const menus = [MenuEntriesEdit, MenuEntriesFile, MenuEntriesGo, MenuEntriesHelp, MenuEntriesRun, MenuEntriesSelection, MenuEntriesTerminal, MenuEntriesTitleBar, MenuEntriesView, MenuEntriesOpenRecent];
 
 const getMenuIds = () => {
@@ -2886,7 +3081,6 @@ const getMenuEntries = (id, platform) => {
 };
 
 // TODO lazyload menuEntries and use Command.execute (maybe)
-const CONTEXT_MENU_WIDTH = 250;
 
 // TODO difference between focusing with mouse or keyboard
 // with mouse -> open submenu
@@ -2900,49 +3094,6 @@ const CONTEXT_MENU_WIDTH = 250;
 
 // TODO more tests
 
-const CONTEXT_MENU_ITEM_HEIGHT = 26;
-const CONTEXT_MENU_SEPARATOR_HEIGHT = 11;
-const CONTEXT_MENU_PADDING = 8;
-const getMenuHeight = items => {
-  let height = CONTEXT_MENU_PADDING;
-  for (const item of items) {
-    switch (item.flags) {
-      case Separator$1:
-        height += CONTEXT_MENU_SEPARATOR_HEIGHT;
-        break;
-      default:
-        height += CONTEXT_MENU_ITEM_HEIGHT;
-        break;
-    }
-  }
-  return height;
-};
-const getMenuBounds = (x, y, items) => {
-  const menuWidth = CONTEXT_MENU_WIDTH;
-  const menuHeight = getMenuHeight(items);
-  const layoutState = {
-    points: [0, 0]
-  };
-  const windowWidth = layoutState.points[0];
-  const windowHeight = layoutState.points[1];
-  // TODO maybe only send labels and keybindings to ui (id not needed on ui)
-  // TODO what about separators?
-
-  if (x + menuWidth > windowWidth) {
-    x -= menuWidth;
-    x = Math.max(x, 0);
-  }
-  if (y + menuHeight > windowHeight) {
-    y -= menuHeight;
-    y = Math.max(y, 0);
-  }
-  return {
-    x,
-    y,
-    width: menuWidth,
-    height: menuHeight
-  };
-};
 const getMenuShowCommands = async (items, menuId, x, y, mouseBlocking = false) => {
   const bounds = getMenuBounds(x, y, items);
   const menu = addMenuInternal({
@@ -2969,13 +3120,20 @@ const handleContextMenu = state => {
 const hideSubMenus = async level => {
   if (level < getCount()) {
     set$1(getAll().slice(0, level + 1));
-    return {
-      commands: [/* Menu.hideSubMenu */'Menu.hideSubMenu', /* level */level + 1],
-      menus: getAll()
-    };
+    await invoke$3('Menu.hideSubMenu', /* level */level + 1);
   }
 };
 
+const MENU_DELAY_TRIANGLE = 300;
+const resolveAfterTimeout = async () => {
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  setTimeout(resolve, MENU_DELAY_TRIANGLE);
+  await promise;
+};
+
 const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
   // TODO delete old menus
   set$1(getAll().slice(0, level + 1));
@@ -2993,23 +3151,15 @@ const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
     enterY
   });
   const width = getMenuWidth();
-  const height = getMenuHeight$2(subMenuItems);
+  const height = getMenuHeight(subMenuItems);
   const visible = getVisible(subMenu.items, -1, false, subMenu.level);
   const dom = getMenuVirtualDom(visible).slice(1);
-  return {
-    commands: [/* Menu.showMenu */'Menu.showMenu', /* x */subMenu.x, /* y */subMenu.y, /* width */width, /* height */height, /* items */subMenu.items, /* level */subMenu.level, /* parentIndex */index, /* dom */dom],
-    menus: getAll()
-  };
+  await invoke$3(/* Menu.showMenu */'Menu.showMenu', /* x */subMenu.x, /* y */subMenu.y, /* width */width, /* height */height, /* items */subMenu.items, /* level */subMenu.level, /* parentIndex */index, /* dom */dom);
 };
 const showSubMenu = async (level, index) => {
   return showSubMenuAtEnter(level, index, -1, -1);
 };
 
-/* eslint-disable @typescript-eslint/no-implied-eval */
-const MENU_DELAY_TRIANGLE = 300;
-const resolveAfterTimeout = fn => {
-  setTimeout(fn, MENU_DELAY_TRIANGLE);
-};
 const handleMouseEnter = async (level, index, enterX, enterY, enterTimeStamp) => {
   setTimestamp(enterTimeStamp);
   if (level >= getCount()) {
@@ -3024,7 +3174,7 @@ const handleMouseEnter = async (level, index, enterX, enterY, enterTimeStamp) =>
     const subMenuEnterX = subMenu.enterX;
     // TODO should check for triangle position here
     if (enterX >= subMenuEnterX) {
-      await new Promise(resolveAfterTimeout);
+      await resolveAfterTimeout();
       if (getLatestTimestamp() !== enterTimeStamp) {
         return;
       }
@@ -3033,7 +3183,7 @@ const handleMouseEnter = async (level, index, enterX, enterY, enterTimeStamp) =>
   const item = menu.items[index];
   await focusIndex(menu, index);
   switch (item.flags) {
-    case /* SubMenu */4:
+    case SubMenu:
       await showSubMenuAtEnter(menu.level, index, enterX, enterY);
       break;
     default:
@@ -3065,7 +3215,7 @@ const renderFocusedIndex = (oldState, newState) => {
   if (newState.focusedIndex === -1) {
     return [];
   }
-  return ['Viewlet.focusSelector', '.ViewletTitleBarMenuBar'];
+  return [FocusSelector, '.ViewletTitleBarMenuBar'];
 };
 
 const SetMenus = 'setMenus';
@@ -3144,19 +3294,19 @@ const renderEventListeners = () => {
     params: ['handleFocus']
   }, {
     name: HandleMenuClick,
-    params: ['handleMenuClick', 'event.clientX', 'event.clientY']
+    params: ['handleMenuClick', ClientX, ClientY]
   }, {
     name: HandleMenuMouseOver,
-    params: ['handleMenuMouseOver', 'event.clientX', 'event.clientY']
+    params: ['handleMenuMouseOver', ClientX, ClientY]
   }, {
     name: HandleClick,
-    params: ['handleClickAt', 'event.button', 'event.clientX', 'event.clientY']
+    params: ['handleClickAt', Button, ClientX, ClientY]
   }, {
     name: HandlePointerOut,
-    params: ['handlePointerOut', 'event.clientX', 'event.clientY']
+    params: ['handlePointerOut', ClientX, ClientY]
   }, {
     name: HandlePointerOver,
-    params: ['handlePointerOver', 'event.clientX', 'event.clientY']
+    params: ['handlePointerOver', ClientX, ClientY]
   }];
 };
 
@@ -3173,16 +3323,6 @@ const executeMenuItemCommand = async item => {
   await invoke(item.command, ...(item.args || []));
 };
 
-const hide = async (restoreFocus = true) => {
-  const {
-    commands
-  } = await getMenuHideCommands(restoreFocus);
-  if (commands.length > 0) {
-    // @ts-ignore
-    await invoke$2(...commands);
-  }
-};
-
 const selectIndexNone = async (menu, item) => {
   await Promise.all([hide(/* restoreFocus */false), executeMenuItemCommand(item)]);
 };
@@ -3251,12 +3391,13 @@ const wrapCommand = fn => {
 };
 
 const commandMap = {
+  'Menu.closeSubMenu': closeSubMenu,
   'Menu.diff2': diff2,
-  'Menu.focusPrevious': focusPrevious,
   'Menu.focusFirst': focusFirst,
   'Menu.focusIndex': focusIndex,
   'Menu.focusLast': focusLast,
   'Menu.focusNext': focusNext,
+  'Menu.focusPrevious': focusPrevious,
   'Menu.getCommands': getCommandIds,
   'Menu.getHideCommands': getMenuHideCommands,
   'Menu.getKeyBindings': getKeyBindings,
@@ -3267,22 +3408,45 @@ const commandMap = {
   'Menu.handleContextMenu': handleContextMenu,
   'Menu.handleMouseEnter': handleMouseEnter,
   'Menu.handleMouseLeave': handleMouseLeave,
+  'Menu.hide': hide,
   'Menu.hideSubMenus': hideSubMenus,
   'Menu.loadContent': wrapCommand(loadContent),
   'Menu.render2': render2,
   'Menu.renderEventListeners': renderEventListeners,
   'Menu.saveState': saveState,
+  'Menu.selectIndex': selectIndex,
   'Menu.selectItem': selectItem,
   'Menu.show': show,
   'Menu.show2': show2,
   'Menu.showSubMenu': showSubMenu
 };
 
+const send = port => {
+  return sendMessagePortToRendererProcess(port);
+};
+const createRendererProcessRpc = async () => {
+  try {
+    const rpc = await TransferMessagePortRpcParent.create({
+      commandMap: {},
+      send
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create renderer process rpc`);
+  }
+};
+
+const initializeRendererProcess = async () => {
+  const rpc = await createRendererProcessRpc();
+  set$3(rpc);
+};
+
 const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
   set$2(rpc);
+  await initializeRendererProcess();
 };
 
 const main = async () => {