@lvce-editor/menu-worker 2.1.0 → 3.0.0

package/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,7 +875,7 @@ 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);
 };
@@ -821,7 +915,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
+      send$1(ipc, method, ...params);
     },
     invoke(method, ...params) {
       return invoke$4(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;
@@ -1195,8 +1327,10 @@ 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 => {
@@ -1218,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);
@@ -1228,7 +1362,8 @@ const create$1 = rpcId => {
 };
 
 const {
-  invoke: invoke$3} = create$1(RendererProcess);
+  invoke: invoke$3,
+  set: set$3} = create$1(RendererProcess);
 
 const {
   invoke: invoke$2,
@@ -1658,6 +1793,74 @@ const closeSubMenu = async () => {
   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;
@@ -1784,15 +1987,6 @@ const menuEntrySeparator = {
   command: ''
 };
 
-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 id$9 = Edit$1;
 const getMenuEntries$d = () => {
   return [{
@@ -2528,31 +2722,56 @@ const getVisible = (items, focusedIndex, expanded, level) => {
   return visibleItems;
 };
 
+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
@@ -2564,50 +2783,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,
@@ -2622,7 +2800,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,
@@ -2635,17 +2813,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);
@@ -2654,7 +2825,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);
@@ -2683,7 +2854,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);
 };
@@ -2765,10 +2936,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 = () => {
@@ -2896,20 +3064,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 = () => {
@@ -2924,7 +3078,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
@@ -2938,49 +3091,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({
@@ -3007,17 +3117,18 @@ 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);
   }
 };
 
-/* eslint-disable @typescript-eslint/no-implied-eval */
 const MENU_DELAY_TRIANGLE = 300;
-const resolveAfterTimeout = fn => {
-  setTimeout(fn, MENU_DELAY_TRIANGLE);
+const resolveAfterTimeout = async () => {
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  setTimeout(resolve, MENU_DELAY_TRIANGLE);
+  await promise;
 };
 
 const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
@@ -3037,13 +3148,10 @@ 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);
@@ -3063,7 +3171,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;
       }
@@ -3072,7 +3180,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:
@@ -3104,7 +3212,7 @@ const renderFocusedIndex = (oldState, newState) => {
   if (newState.focusedIndex === -1) {
     return [];
   }
-  return ['Viewlet.focusSelector', '.ViewletTitleBarMenuBar'];
+  return [FocusSelector, '.ViewletTitleBarMenuBar'];
 };
 
 const SetMenus = 'setMenus';
@@ -3183,19 +3291,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]
   }];
 };
 
@@ -3212,16 +3320,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)]);
 };
@@ -3290,13 +3388,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.closeSubMenu': closeSubMenu,
   'Menu.focusNext': focusNext,
+  'Menu.focusPrevious': focusPrevious,
   'Menu.getCommands': getCommandIds,
   'Menu.getHideCommands': getMenuHideCommands,
   'Menu.getKeyBindings': getKeyBindings,
@@ -3307,22 +3405,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 () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/menu-worker",
-  "version": "2.1.0",
+  "version": "3.0.0",
   "description": "Menu Worker",
   "repository": {
     "type": "git",