@lvce-editor/menu-worker 1.6.0 → 2.0.0

package/dist/menuWorkerMain.js

@@ -421,10 +421,10 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$3 = (id, fn) => {
+const set$4 = (id, fn) => {
   callbacks[id] = fn;
 };
-const get$2 = id => {
+const get$3 = id => {
   return callbacks[id];
 };
 const remove = id => {
@@ -440,7 +440,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$3(id, resolve);
+  set$4(id, resolve);
   return {
     id,
     promise
@@ -601,14 +601,14 @@ const unwrapJsonRpcResult = responseMessage => {
   }
   throw new JsonRpcError('unexpected response message');
 };
-const warn = (...args) => {
+const warn$1 = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$2(id);
+  const fn = get$3(id);
   if (!fn) {
     console.log(response);
-    warn(`callback ${id} may already be disposed`);
+    warn$1(`callback ${id} may already be disposed`);
     return;
   }
   fn(response);
@@ -785,10 +785,10 @@ const send = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-const invoke$2 = (ipc, method, ...params) => {
+const invoke$3 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer = (ipc, method, ...params) => {
+const invokeAndTransfer$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -824,10 +824,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$2(ipc, method, ...params);
+      return invoke$3(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
+      return invokeAndTransfer$1(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -879,6 +879,25 @@ const WebWorkerRpcClient = {
   __proto__: null,
   create: create$2
 };
+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 = {
+    invoke,
+    invokeAndTransfer: invoke,
+    invocations
+  };
+  return mockRpc;
+};
 
 const Text = 12;
 
@@ -1151,6 +1170,13 @@ const getKeyCodeString = keyCode => {
 const CtrlCmd = 1 << 11 >>> 0;
 const Shift = 1 << 10 >>> 0;
 
+const Separator$2 = 1;
+const None$1 = 0;
+const SubMenu$1 = 4;
+const Disabled$1 = 5;
+const RestoreFocus$1 = 6;
+const Ignore$1 = 7;
+
 const parseKey = rawKey => {
   const isCtrl = Boolean(rawKey & CtrlCmd);
   const isShift = Boolean(rawKey & Shift);
@@ -1163,13 +1189,14 @@ const parseKey = rawKey => {
   };
 };
 
-const RendererWorker = 1;
+const DebugWorker = 55;
+const RendererWorker$1 = 1;
 
 const rpcs = Object.create(null);
-const set$2 = (id, rpc) => {
+const set$3 = (id, rpc) => {
   rpcs[id] = rpc;
 };
-const get$1 = id => {
+const get$2 = id => {
   return rpcs[id];
 };
 
@@ -1177,29 +1204,380 @@ const create$1 = rpcId => {
   return {
     // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       // @ts-ignore
       return rpc.invoke(method, ...params);
     },
     // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$2(rpcId, rpc);
+      set$3(rpcId, rpc);
     },
     async dispose() {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       await rpc.dispose();
     }
   };
 };
 
 const {
-  invoke: invoke$1,
-  set: set$1} = create$1(RendererWorker);
+  invoke: invoke$2,
+  invokeAndTransfer,
+  set: set$2,
+  dispose
+} = create$1(RendererWorker$1);
+const searchFileHtml = async uri => {
+  return invoke$2('ExtensionHost.searchFileWithHtml', uri);
+};
+const getFilePathElectron = async file => {
+  return invoke$2('FileSystemHandle.getFilePathElectron', file);
+};
+const showContextMenu = async (x, y, id, ...args) => {
+  return invoke$2('ContextMenu.show', x, y, id, ...args);
+};
+const getElectronVersion = async () => {
+  return invoke$2('Process.getElectronVersion');
+};
+const applyBulkReplacement = async bulkEdits => {
+  await invoke$2('BulkReplacement.applyBulkReplacement', bulkEdits);
+};
+const setColorTheme = async id => {
+  // @ts-ignore
+  return invoke$2(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+};
+const getNodeVersion = async () => {
+  return invoke$2('Process.getNodeVersion');
+};
+const getChromeVersion = async () => {
+  return invoke$2('Process.getChromeVersion');
+};
+const getV8Version = async () => {
+  return invoke$2('Process.getV8Version');
+};
+const getFileHandles = async fileIds => {
+  const files = await invoke$2('FileSystemHandle.getFileHandles', fileIds);
+  return files;
+};
+const setWorkspacePath = async path => {
+  await invoke$2('Workspace.setPath', path);
+};
+const registerWebViewInterceptor = async (id, port) => {
+  await invokeAndTransfer('WebView.registerInterceptor', id, port);
+};
+const unregisterWebViewInterceptor = async id => {
+  await invoke$2('WebView.unregisterInterceptor', id);
+};
+const sendMessagePortToEditorWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+};
+const sendMessagePortToErrorWorker = async (port, rpcId) => {
+  const command = 'Errors.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+};
+const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
+  const command = 'Markdown.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
+};
+const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
+  const command = 'IconTheme.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
+};
+const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
+  const command = 'FileSystem.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
+const readFile = async uri => {
+  return invoke$2('FileSystem.readFile', uri);
+};
+const getWebViewSecret = async key => {
+  // @ts-ignore
+  return invoke$2('WebView.getSecret', key);
+};
+const setWebViewPort = async (uid, port, origin, portType) => {
+  return invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
+};
+const setFocus = key => {
+  return invoke$2('Focus.setFocus', key);
+};
+const getFileIcon = async options => {
+  return invoke$2('IconTheme.getFileIcon', options);
+};
+const getColorThemeNames = async () => {
+  return invoke$2('ColorTheme.getColorThemeNames');
+};
+const disableExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.disable', id);
+};
+const enableExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.enable', id);
+};
+const handleDebugChange = async params => {
+  // @ts-ignore
+  return invoke$2('Run And Debug.handleChange', params);
+};
+const getFolderIcon = async options => {
+  return invoke$2('IconTheme.getFolderIcon', options);
+};
+const closeWidget = async widgetId => {
+  return invoke$2('Viewlet.closeWidget', widgetId);
+};
+const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const sendMessagePortToSearchProcess = async port => {
+  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+};
+const confirm = async (message, options) => {
+  // @ts-ignore
+  const result = await invoke$2('ConfirmPrompt.prompt', message, options);
+  return result;
+};
+const getRecentlyOpened$1 = async () => {
+  return invoke$2(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+};
+const getKeyBindings$1 = async () => {
+  return invoke$2('KeyBindingsInitial.getKeyBindings');
+};
+const writeClipBoardText = async text => {
+  await invoke$2('ClipBoard.writeText', /* text */text);
+};
+const writeClipBoardImage = async blob => {
+  // @ts-ignore
+  await invoke$2('ClipBoard.writeImage', /* text */blob);
+};
+const searchFileMemory = async uri => {
+  // @ts-ignore
+  return invoke$2('ExtensionHost.searchFileWithMemory', uri);
+};
+const searchFileFetch = async uri => {
+  return invoke$2('ExtensionHost.searchFileWithFetch', uri);
+};
+const showMessageBox = async options => {
+  return invoke$2('ElectronDialog.showMessageBox', options);
+};
+const handleDebugResumed = async params => {
+  await invoke$2('Run And Debug.handleResumed', params);
+};
+const openWidget = async name => {
+  await invoke$2('Viewlet.openWidget', name);
+};
+const getIcons = async requests => {
+  const icons = await invoke$2('IconTheme.getIcons', requests);
+  return icons;
+};
+const activateByEvent = event => {
+  return invoke$2('ExtensionHostManagement.activateByEvent', event);
+};
+const setAdditionalFocus = focusKey => {
+  // @ts-ignore
+  return invoke$2('Focus.setAdditionalFocus', focusKey);
+};
+const getActiveEditorId = () => {
+  // @ts-ignore
+  return invoke$2('GetActiveEditor.getActiveEditorId');
+};
+const getWorkspacePath = () => {
+  return invoke$2('Workspace.getPath');
+};
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+};
+const getPreference = async key => {
+  return await invoke$2('Preferences.get', key);
+};
+const getAllExtensions = async () => {
+  return invoke$2('ExtensionManagement.getAllExtensions');
+};
+const rerenderEditor = async key => {
+  // @ts-ignore
+  return invoke$2('Editor.rerender', key);
+};
+const handleDebugPaused = async params => {
+  await invoke$2('Run And Debug.handlePaused', params);
+};
+const openUri = async (uri, focus, options) => {
+  await invoke$2('Main.openUri', uri, focus, options);
+};
+const sendMessagePortToSyntaxHighlightingWorker = async port => {
+  await invokeAndTransfer(
+  // @ts-ignore
+  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
+};
+const handleDebugScriptParsed = async script => {
+  await invoke$2('Run And Debug.handleScriptParsed', script);
+};
+const getWindowId = async () => {
+  return invoke$2('GetWindowId.getWindowId');
+};
+const getBlob = async uri => {
+  // @ts-ignore
+  return invoke$2('FileSystem.getBlob', uri);
+};
+const getExtensionCommands = async () => {
+  return invoke$2('ExtensionHost.getCommands');
+};
+const showErrorDialog = async errorInfo => {
+  // @ts-ignore
+  await invoke$2('ErrorHandling.showErrorDialog', errorInfo);
+};
+const getFolderSize = async uri => {
+  // @ts-ignore
+  return await invoke$2('FileSystem.getFolderSize', uri);
+};
+const getExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.getExtension', id);
+};
+const getMarkdownDom = async html => {
+  // @ts-ignore
+  return invoke$2('Markdown.getVirtualDom', html);
+};
+const renderMarkdown = async (markdown, options) => {
+  // @ts-ignore
+  return invoke$2('Markdown.renderMarkdown', markdown, options);
+};
+const openNativeFolder = async uri => {
+  // @ts-ignore
+  await invoke$2('OpenNativeFolder.openNativeFolder', uri);
+};
+const uninstallExtension = async id => {
+  return invoke$2('ExtensionManagement.uninstall', id);
+};
+const installExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.install', id);
+};
+const openExtensionSearch = async () => {
+  // @ts-ignore
+  return invoke$2('SideBar.openViewlet', 'Extensions');
+};
+const setExtensionsSearchValue = async searchValue => {
+  // @ts-ignore
+  return invoke$2('Extensions.handleInput', searchValue);
+};
+const openExternal = async uri => {
+  // @ts-ignore
+  await invoke$2('Open.openExternal', uri);
+};
+const openUrl = async uri => {
+  // @ts-ignore
+  await invoke$2('Open.openUrl', uri);
+};
+const getAllPreferences = async () => {
+  // @ts-ignore
+  return invoke$2('Preferences.getAll');
+};
+const showSaveFilePicker = async () => {
+  // @ts-ignore
+  return invoke$2('FilePicker.showSaveFilePicker');
+};
+const getLogsDir = async () => {
+  // @ts-ignore
+  return invoke$2('PlatformPaths.getLogsDir');
+};
+const registerMockRpc = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$2(mockRpc);
+  return mockRpc;
+};
+
+const RendererWorker = {
+  __proto__: null,
+  activateByEvent,
+  applyBulkReplacement,
+  closeWidget,
+  confirm,
+  disableExtension,
+  dispose,
+  enableExtension,
+  getActiveEditorId,
+  getAllExtensions,
+  getAllPreferences,
+  getBlob,
+  getChromeVersion,
+  getColorThemeNames,
+  getElectronVersion,
+  getExtension,
+  getExtensionCommands,
+  getFileHandles,
+  getFileIcon,
+  getFilePathElectron,
+  getFolderIcon,
+  getFolderSize,
+  getIcons,
+  getKeyBindings: getKeyBindings$1,
+  getLogsDir,
+  getMarkdownDom,
+  getNodeVersion,
+  getPreference,
+  getRecentlyOpened: getRecentlyOpened$1,
+  getV8Version,
+  getWebViewSecret,
+  getWindowId,
+  getWorkspacePath,
+  handleDebugChange,
+  handleDebugPaused,
+  handleDebugResumed,
+  handleDebugScriptParsed,
+  installExtension,
+  invoke: invoke$2,
+  invokeAndTransfer,
+  openExtensionSearch,
+  openExternal,
+  openNativeFolder,
+  openUri,
+  openUrl,
+  openWidget,
+  readFile,
+  registerMockRpc,
+  registerWebViewInterceptor,
+  renderMarkdown,
+  rerenderEditor,
+  searchFileFetch,
+  searchFileHtml,
+  searchFileMemory,
+  sendMessagePortToEditorWorker,
+  sendMessagePortToErrorWorker,
+  sendMessagePortToExtensionHostWorker,
+  sendMessagePortToFileSystemWorker,
+  sendMessagePortToIconThemeWorker,
+  sendMessagePortToMarkdownWorker,
+  sendMessagePortToRendererProcess,
+  sendMessagePortToSearchProcess,
+  sendMessagePortToSyntaxHighlightingWorker,
+  set: set$2,
+  setAdditionalFocus,
+  setColorTheme,
+  setExtensionsSearchValue,
+  setFocus,
+  setWebViewPort,
+  setWorkspacePath,
+  showContextMenu,
+  showErrorDialog,
+  showMessageBox,
+  showSaveFilePicker,
+  uninstallExtension,
+  unregisterWebViewInterceptor,
+  writeClipBoardImage,
+  writeClipBoardText
+};
 
 const matchesArgs = (a, b) => {
   if (!a && !b) {
@@ -1227,8 +1605,14 @@ const getCommandKeyBinding = (keyBindings, command, args) => {
   return undefined;
 };
 
-const invoke = async (method, ...params) => {
-  // TODO
+/* eslint-disable no-console */
+const warn = (...args) => {
+  console.warn(...args);
+};
+
+const invoke$1 = async (method, ...params) => {
+  // @ts-ignore
+  await invoke$2('WebView.compatRendererProcessInvoke', method, ...params);
 };
 
 const state$1 = {
@@ -1540,7 +1924,7 @@ const MenuEntriesHelp = {
 };
 
 const getRecentlyOpened = () => {
-  return invoke$1(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+  return invoke$2(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
 };
 
 const File = 'file://';
@@ -1799,33 +2183,13 @@ const menus$1 = [MenuEntriesEdit, MenuEntriesFile, MenuEntriesGo, MenuEntriesHel
 const getMenus = () => {
   return menus$1;
 };
-const getModule$1 = id => {
-  for (const module of menus$1) {
-    if (module.id === id) {
-      return module;
-    }
-  }
-  return undefined;
-};
 const getMenuEntries$1 = async (id, ...args) => {
-  try {
-    const module = getModule$1(id);
-    // @ts-ignore
-    const inject = module.inject || [];
-    // @ts-ignore
-    return module.getMenuEntries(...args);
-  } catch (error) {
-    throw new VError(error, `Failed to load menu entries for id ${id}`);
-  }
+  // @ts-ignore
+  return invoke$2('Menu.getMenuEntries', id, ...args);
 };
 const getMenuEntries2 = async (uid, menuId, ...args) => {
-  try {
-    const module = await getModule$1(menuId);
-    // @ts-ignore
-    return module.getMenuEntries(uid, ...args);
-  } catch (error) {
-    throw new VError(error, `Failed to load menu entries for id ${menuId}`);
-  }
+  // @ts-ignore
+  return invoke$2('Menu.getMenuEntries2', uid, menuId, ...args);
 };
 
 const addKeyBindings = menuEntries => {
@@ -2095,7 +2459,8 @@ const getVisible = (items, focusedIndex, expanded, level) => {
 // TODO this code seems a bit too complicated, maybe it can be simplified
 
 const state = {
-  menus: []};
+  menus: [],
+  latestTimeStamp: 0};
 const addMenuInternal = menu => {
   if (state.menus.length > 5) {
     throw new Error('too many menus');
@@ -2109,12 +2474,51 @@ const getCount = () => {
 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;
+};
+
+// 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;
+  for (const item of items) {
+    switch (item.flags) {
+      case Separator$1:
+        height += CONTEXT_MENU_SEPARATOR_HEIGHT$2;
+        break;
+      default:
+        height += CONTEXT_MENU_ITEM_HEIGHT$2;
+        break;
+    }
+  }
+  return height;
+};
 
 // 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
+// with keyboard -> don't open submenu, only focus
 
 // TODO handle printable letter and focus item that starts with that letter
 
@@ -2176,7 +2580,7 @@ const show$2 = async (x, y, id, mouseBlocking = false, ...args) => {
   });
   const visible = getVisible(menu.items, -1, false, menu.level);
   const dom = getMenuVirtualDom(visible).slice(1);
-  await invoke(/* 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);
+  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 show2$2 = async (uid, menuId, x, y, mouseBlocking = false, ...args) => {
   const items = await getMenuEntriesWithKeyBindings2(uid, menuId, ...args);
@@ -2191,19 +2595,19 @@ const show2$2 = async (uid, menuId, x, y, mouseBlocking = false, ...args) => {
   });
   const visible = getVisible(menu.items, -1, false, menu.level);
   const dom = getMenuVirtualDom(visible).slice(1);
-  await invoke(/* 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);
+  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 = async (restoreFocus = true) => {
+const hide$1 = async (restoreFocus = true) => {
   if (getCount() === 0) {
     return;
   }
   reset();
-  await invoke(/* Menu.hide */'Menu.hide', /* restoreFocus */restoreFocus);
+  await invoke$1(/* Menu.hide */'Menu.hide', /* restoreFocus */restoreFocus);
 };
 
 const show$1 = async (x, y, id, ...args) => {
   // @ts-ignore
-  await hide();
+  await hide$1();
   // TODO handle error
   // TODO race condition
   await show$2(x, y, id, /* mouseBlocking */true, ...args);
@@ -2212,7 +2616,7 @@ const show$1 = async (x, y, id, ...args) => {
 };
 const show2$1 = async (uid, menuId, x, y, ...args) => {
   // @ts-ignore
-  await hide();
+  await hide$1();
   // TODO handle error
   // TODO race condition
   await show2$2(uid, menuId, x, y, /* mouseBlocking */true, ...args);
@@ -2307,6 +2711,109 @@ const diff2 = uid => {
   return diff(oldState, newState);
 };
 
+const canBeFocused = item => {
+  switch (item.flags) {
+    case Separator$2:
+    case Disabled$1:
+      return false;
+    default:
+      return true;
+  }
+};
+
+const focusIndex = async (menu, index) => {
+  if (menu.items.length === 0) {
+    return;
+  }
+  const oldFocusedIndex = menu.focusedIndex;
+  menu.focusedIndex = index;
+  return {
+    commands: [/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */index],
+    menus: getAll()
+  };
+};
+
+const getCurrentMenu = () => {
+  if (getCount() === 0) {
+    warn('menu not available');
+  }
+  return getAll().at(-1);
+};
+const getIndexToFocusNextStartingAt = (items, startIndex) => {
+  for (let i = startIndex; i < startIndex + items.length; i++) {
+    const index = i % items.length;
+    const item = items[index];
+    if (canBeFocused(item)) {
+      return index;
+    }
+  }
+  return -1;
+};
+const getIndexToFocusFirst = items => {
+  return getIndexToFocusNextStartingAt(items, 0);
+};
+const focusFirst = async () => {
+  const menu = getCurrentMenu();
+  if (getCount() === 0) {
+    return;
+  }
+  const indexToFocus = getIndexToFocusFirst(menu.items);
+  await focusIndex(menu, indexToFocus);
+};
+
+const getIndexToFocusPreviousStartingAt$1 = (items, startIndex) => {
+  for (let i = startIndex; i > startIndex - items.length; i--) {
+    const index = (i + items.length) % items.length;
+    const item = items[index];
+    if (canBeFocused(item)) {
+      return index;
+    }
+  }
+  return -1;
+};
+const focusLast = async () => {
+  const menu = getCurrentMenu();
+  const indexToFocus = getIndexToFocusPreviousStartingAt$1(menu.items, menu.items.length - 1);
+  await focusIndex(menu, indexToFocus);
+};
+
+const getIndexToFocusNext = menu => {
+  const startIndex = menu.focusedIndex + 1;
+  return getIndexToFocusNextStartingAt(menu.items, startIndex);
+};
+const focusNext = async () => {
+  const menu = getCurrentMenu();
+  if (menu.items.length === 0) {
+    return;
+  }
+  const indexToFocus = getIndexToFocusNext(menu);
+  await focusIndex(menu, indexToFocus);
+};
+
+// TODO this code seems a bit too complicated, maybe it can be simplified
+const getIndexToFocusPreviousStartingAt = (items, startIndex) => {
+  for (let i = startIndex; i > startIndex - items.length; i--) {
+    const index = (i + items.length) % items.length;
+    const item = items[index];
+    if (canBeFocused(item)) {
+      return index;
+    }
+  }
+  return -1;
+};
+const getIndexToFocusPrevious = menu => {
+  const startIndex = menu.focusedIndex === -1 ? menu.items.length - 1 : menu.focusedIndex - 1;
+  return getIndexToFocusPreviousStartingAt(menu.items, startIndex);
+};
+const focusPrevious = async () => {
+  const menu = getCurrentMenu();
+  if (menu.items.length === 0) {
+    return;
+  }
+  const indexToFocus = getIndexToFocusPrevious(menu);
+  await focusIndex(menu, indexToFocus);
+};
+
 const commandsIds = ['closeMenu', 'handleClickAt', 'focus', 'focusFirst', 'focusIndex', 'focusLast', 'focusNext', 'focusPrevious', 'handleClick', 'handleFocus', 'handleFocusOut', 'handleKeyArrowDown', 'handleKeyArrowLeft', 'handleKeyArrowRight', 'handleKeyArrowUp', 'handleKeyEnd', 'handleKeyEnter', 'handleKeyEscape', 'handleKeyHome', 'handleKeySpace', 'handleMenuClick', 'handleMenuMouseOver', 'handleMouseOut', 'handleMouseOver', 'handlePointerOver', 'handlePointerOut', 'toggleIndex', 'toggleMenu'];
 
 const getCommandIds = () => {
@@ -2423,9 +2930,11 @@ const getMenuBounds = (x, y, items) => {
 
   if (x + menuWidth > windowWidth) {
     x -= menuWidth;
+    x = Math.max(x, 0);
   }
   if (y + menuHeight > windowHeight) {
     y -= menuHeight;
+    y = Math.max(y, 0);
   }
   return {
     x,
@@ -2457,6 +2966,95 @@ const handleContextMenu = state => {
   return 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()
+    };
+  }
+};
+
+const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
+  // TODO delete old menus
+  set$1(getAll().slice(0, level + 1));
+  const parentMenu = get$1(level);
+  const item = parentMenu.items[index];
+  const subMenuItems = await getMenuEntries$1(item.id);
+  const subMenu = addMenuInternal({
+    id: item.id,
+    items: subMenuItems,
+    focusedIndex: -1,
+    level: getCount(),
+    y: parentMenu.y + index * 25,
+    x: parentMenu.x + MENU_WIDTH,
+    enterX,
+    enterY
+  });
+  const width = getMenuWidth();
+  const height = getMenuHeight$2(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()
+  };
+};
+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()) {
+    return;
+  }
+  const menu = get$1(level);
+  if (menu.focusedIndex === index) {
+    return;
+  }
+  if (level < getCount() - 1) {
+    const subMenu = get$1(level + 1);
+    const subMenuEnterX = subMenu.enterX;
+    // TODO should check for triangle position here
+    if (enterX >= subMenuEnterX) {
+      await new Promise(resolveAfterTimeout);
+      if (getLatestTimestamp() !== enterTimeStamp) {
+        return;
+      }
+    }
+  }
+  const item = menu.items[index];
+  await focusIndex(menu, index);
+  switch (item.flags) {
+    case /* SubMenu */4:
+      await showSubMenuAtEnter(menu.level, index, enterX, enterY);
+      break;
+    default:
+      await hideSubMenus(menu.level);
+      break;
+  }
+};
+
+const handleMouseLeave = async () => {
+  const menu = get$1(0);
+  if (menu.items.length === 0) {
+    return;
+  }
+  const oldFocusedIndex = menu.focusedIndex;
+  menu.focusedIndex = -1;
+  return {
+    commands: [/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */-1],
+    menus: getAll()
+  };
+};
+
 const loadContent = async (state, titleBarEntries) => {
   return {
     ...state
@@ -2568,6 +3166,75 @@ const saveState = uid => {
   };
 };
 
+const {
+  invoke} = RendererWorker;
+
+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)]);
+};
+const selectIndexRestoreFocus = async (menu, item) => {
+  await Promise.all([hide(/* restoreFocus */true), executeMenuItemCommand(item)]);
+};
+const selectIndexSubMenu = async (menu, item, index) => {
+  if (menu.focusedIndex === index) {
+    return;
+  }
+  await showSubMenu(menu.level, menu.focusedIndex);
+};
+const selectIndexDefault = async () => {};
+const selectIndexIgnore = async (menu, item) => {
+  await executeMenuItemCommand(item);
+};
+const getSelectIndexFunction = flags => {
+  switch (flags) {
+    case None$1:
+      return selectIndexNone;
+    case SubMenu$1:
+      return selectIndexSubMenu;
+    case RestoreFocus$1:
+      return selectIndexRestoreFocus;
+    case Ignore$1:
+      return selectIndexIgnore;
+    default:
+      return selectIndexDefault;
+  }
+};
+const selectIndex = async (level, index) => {
+  const menu = get$1(level);
+  // TODO avoid assignment
+  menu.focusedIndex = index;
+  const item = menu.items[menu.focusedIndex];
+  const fn = getSelectIndexFunction(item.flags);
+  await fn(menu, item, index);
+};
+
+const selectItem = async text => {
+  for (let level = 0; level < getCount(); level++) {
+    const menu = get$1(level);
+    for (let i = 0; i < menu.items.length; i++) {
+      const item = menu.items[i];
+      if (item.label === text) {
+        return selectIndex(level, i);
+      }
+    }
+  }
+  throw new Error(`menu item not found: ${text}`);
+};
+
 const wrapCommand = fn => {
   const wrapped = async (uid, ...args) => {
     const {
@@ -2584,28 +3251,38 @@ const wrapCommand = fn => {
 };
 
 const commandMap = {
-  'Menu.getMenuEntries': getMenuEntries,
-  'Menu.getMenuIds': getMenuIds,
-  'Menu.handleContextMenu': handleContextMenu,
-  'Menu.renderEventListeners': renderEventListeners,
   'Menu.diff2': diff2,
+  'Menu.focusPrevious': focusPrevious,
+  'Menu.focusFirst': focusFirst,
+  'Menu.focusIndex': focusIndex,
+  'Menu.focusLast': focusLast,
+  'Menu.focusNext': focusNext,
   'Menu.getCommands': getCommandIds,
+  'Menu.getHideCommands': getMenuHideCommands,
   'Menu.getKeyBindings': getKeyBindings,
+  'Menu.getMenuEntries': getMenuEntries,
+  'Menu.getMenuIds': getMenuIds,
   'Menu.getMenus': getMenus,
+  'Menu.getShowCommands': getMenuShowCommands,
+  'Menu.handleContextMenu': handleContextMenu,
+  'Menu.handleMouseEnter': handleMouseEnter,
+  'Menu.handleMouseLeave': handleMouseLeave,
+  'Menu.hideSubMenus': hideSubMenus,
   'Menu.loadContent': wrapCommand(loadContent),
   'Menu.render2': render2,
+  'Menu.renderEventListeners': renderEventListeners,
   'Menu.saveState': saveState,
+  'Menu.selectItem': selectItem,
   'Menu.show': show,
   'Menu.show2': show2,
-  'Menu.getShowCommands': getMenuShowCommands,
-  'Menu.getHideCommands': getMenuHideCommands
+  'Menu.showSubMenu': showSubMenu
 };
 
 const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set$1(rpc);
+  set$2(rpc);
 };
 
 const main = async () => {

package/package.json

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