@lvce-editor/menu-worker 1.7.0 → 2.1.0

package/dist/menuWorkerMain.js

@@ -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$4 = (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$4(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;
 
@@ -1148,11 +1167,17 @@ const getKeyCodeString = keyCode => {
   }
 };
 
+const Script = 2;
+
 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);
@@ -1166,7 +1191,9 @@ const parseKey = rawKey => {
   };
 };
 
-const RendererWorker = 1;
+const DebugWorker = 55;
+const RendererProcess = 1670;
+const RendererWorker$1 = 1;
 
 const rpcs = Object.create(null);
 const set$3 = (id, rpc) => {
@@ -1201,8 +1228,435 @@ const create$1 = rpcId => {
 };
 
 const {
-  invoke: invoke$1,
-  set: set$2} = create$1(RendererWorker);
+  invoke: invoke$3} = create$1(RendererProcess);
+
+const {
+  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 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');
+};
+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 readClipBoardText = async () => {
+  return invoke$2('ClipBoard.readText');
+};
+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 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);
+};
+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, Script);
+};
+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,
+  readClipBoardText,
+  readFile,
+  registerMockRpc,
+  registerWebViewInterceptor,
+  renderMarkdown,
+  rerenderEditor,
+  searchFileFetch,
+  searchFileHtml,
+  searchFileMemory,
+  sendMessagePortToEditorWorker,
+  sendMessagePortToErrorWorker,
+  sendMessagePortToExtensionHostWorker,
+  sendMessagePortToFileSystemWorker,
+  sendMessagePortToIconThemeWorker,
+  sendMessagePortToMarkdownWorker,
+  sendMessagePortToRendererProcess,
+  sendMessagePortToSearchProcess,
+  sendMessagePortToSourceControlWorker,
+  sendMessagePortToSyntaxHighlightingWorker,
+  sendMessagePortToTextMeasurementWorker,
+  set: set$2,
+  setAdditionalFocus,
+  setColorTheme,
+  setExtensionsSearchValue,
+  setFocus,
+  setWebViewPort,
+  setWorkspacePath,
+  showContextMenu,
+  showContextMenu2,
+  showErrorDialog,
+  showMessageBox,
+  showSaveFilePicker,
+  uninstallExtension,
+  unregisterWebViewInterceptor,
+  writeClipBoardImage,
+  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 matchesArgs = (a, b) => {
   if (!a && !b) {
@@ -1235,11 +1689,12 @@ const warn = (...args) => {
   console.warn(...args);
 };
 
-const invoke = async (method, ...params) => {
-  // TODO
+const invoke$1 = async (method, ...params) => {
+  // @ts-ignore
+  await invoke$2('WebView.compatRendererProcessInvoke', method, ...params);
 };
 
-const state$1 = {
+const state = {
   /**
    * @type {any}
    */
@@ -1322,6 +1777,13 @@ const Terminal$1 = 14;
 const TitleBar = 15;
 const View$1 = 16;
 
+const menuEntrySeparator = {
+  id: 'separator',
+  label: '',
+  flags: Separator$2,
+  command: ''
+};
+
 const Separator$1 = 1;
 const None = 0;
 const SubMenu = 4;
@@ -1331,13 +1793,6 @@ const Disabled = 5;
 const RestoreFocus = 6;
 const Ignore = 7;
 
-const menuEntrySeparator = {
-  id: 'separator',
-  label: '',
-  flags: Separator$1,
-  command: ''
-};
-
 const id$9 = Edit$1;
 const getMenuEntries$d = () => {
   return [{
@@ -1548,7 +2003,7 @@ const MenuEntriesHelp = {
 };
 
 const getRecentlyOpened = () => {
-  return invoke$1(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+  return invoke$2(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
 };
 
 const File = 'file://';
@@ -1807,37 +2262,17 @@ 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 => {
-  const keyBindings = state$1.matchingKeyBindings;
+  const keyBindings = state.matchingKeyBindings;
   const newMenuEntries = [];
   for (const menuEntry of menuEntries) {
     const keyBinding = getCommandKeyBinding(keyBindings, menuEntry.command, menuEntry.args);
@@ -2093,47 +2528,6 @@ 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;
-};
-
 // TODO lazyload menuEntries and use Command.execute (maybe)
 const CONTEXT_MENU_ITEM_HEIGHT$2 = 26;
 const CONTEXT_MENU_SEPARATOR_HEIGHT$2 = 11;
@@ -2160,6 +2554,10 @@ 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
 
 // TODO pageup / pagedown keys
@@ -2220,7 +2618,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);
@@ -2235,19 +2633,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);
@@ -2256,7 +2654,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);
@@ -2401,6 +2799,22 @@ const focusFirst = async () => {
   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);
@@ -2414,6 +2828,30 @@ const focusNext = async () => {
   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 = () => {
@@ -2530,9 +2968,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,
@@ -2574,6 +3014,12 @@ const hideSubMenus = async level => {
   }
 };
 
+/* eslint-disable @typescript-eslint/no-implied-eval */
+const MENU_DELAY_TRIANGLE = 300;
+const resolveAfterTimeout = fn => {
+  setTimeout(fn, MENU_DELAY_TRIANGLE);
+};
+
 const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
   // TODO delete old menus
   set$1(getAll().slice(0, level + 1));
@@ -2603,11 +3049,6 @@ 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()) {
@@ -2764,6 +3205,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 {
@@ -2781,7 +3291,11 @@ const wrapCommand = fn => {
 
 const commandMap = {
   'Menu.diff2': diff2,
+  'Menu.focusPrevious': focusPrevious,
   'Menu.focusFirst': focusFirst,
+  'Menu.focusIndex': focusIndex,
+  'Menu.focusLast': focusLast,
+  'Menu.closeSubMenu': closeSubMenu,
   'Menu.focusNext': focusNext,
   'Menu.getCommands': getCommandIds,
   'Menu.getHideCommands': getMenuHideCommands,
@@ -2798,6 +3312,7 @@ const commandMap = {
   'Menu.render2': render2,
   'Menu.renderEventListeners': renderEventListeners,
   'Menu.saveState': saveState,
+  'Menu.selectItem': selectItem,
   'Menu.show': show,
   'Menu.show2': show2,
   'Menu.showSubMenu': showSubMenu

package/package.json

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