@lvce-editor/extension-search-view 4.4.0 → 4.6.0

package/dist/extensionSearchViewWorkerMain.js

@@ -417,9 +417,103 @@ 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) => {
+const create$4$1 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -427,7 +521,7 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$4 = (id, fn) => {
+const set$6 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
@@ -446,7 +540,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$4(id, resolve);
+  set$6(id, resolve);
   return {
     id,
     promise
@@ -674,7 +768,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,
@@ -683,7 +777,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 {
@@ -788,13 +882,13 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   return unwrapJsonRpcResult(responseMessage);
 };
 const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
+  const message = create$4$1(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$1 = (ipc, method, ...params) => {
+const invokeAndTransfer$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -830,10 +924,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$1(ipc, method, ...params);
+      return invokeAndTransfer$2(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -871,7 +965,41 @@ 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$4 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -883,7 +1011,7 @@ const create$3 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$3
+  create: create$4
 };
 const createMockRpc = ({
   commandMap
@@ -905,7 +1033,7 @@ const createMockRpc = ({
   return mockRpc;
 };
 
-const toCommandId$1 = key => {
+const toCommandId = key => {
   const dotIndex = key.indexOf('.');
   return key.slice(dotIndex + 1);
 };
@@ -977,7 +1105,7 @@ const create$2 = () => {
     },
     getCommandIds() {
       const keys = Object.keys(commandMapRef);
-      const ids = keys.map(toCommandId$1);
+      const ids = keys.map(toCommandId);
       return ids;
     },
     registerCommands(commandMap) {
@@ -1017,7 +1145,7 @@ const SearchExtensionsInMarketplace = 'Search Extensions in Marketplace';
 const ViewsAndMoreActions = 'Views and more Actions...';
 const Extensions$2 = 'Extensions';
 const Copy = 'Copy';
-const CopyExtensionId = 'CopyExtensionId';
+const CopyExtensionId = 'Copy Extension Id';
 const Name = 'Name';
 const Id$1 = 'Id';
 const Description = 'Description';
@@ -1333,10 +1461,11 @@ const TargetValue = 'event.target.value';
 const LeftClick = 0;
 
 const DebugWorker = 55;
+const ExtensionHostWorker = 44;
 const RendererWorker$1 = 1;
 
 const rpcs = Object.create(null);
-const set$3 = (id, rpc) => {
+const set$5 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
@@ -1358,7 +1487,7 @@ const create$1 = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$3(rpcId, rpc);
+      set$5(rpcId, rpc);
     },
     async dispose() {
       const rpc = get$1(rpcId);
@@ -1368,51 +1497,89 @@ const create$1 = rpcId => {
 };
 
 const {
-  invoke: invoke$1,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$1,
+  set: set$4,
+  dispose: dispose$3
+} = create$1(ExtensionHostWorker);
+const executeReferenceProvider = async (id, offset) => {
+  // @ts-ignore
+  return invoke$3('ExtensionHostReference.executeReferenceProvider', id, offset);
+};
+const executeFileReferenceProvider = async id => {
+  // @ts-ignore
+  return invoke$3('ExtensionHostReference.executeFileReferenceProvider', id);
+};
+const getRuntimeStatus = async extensionId => {
+  // @ts-ignore
+  return invoke$3('ExtensionHost.getRuntimeStatus', extensionId);
+};
+const registerMockRpc$1 = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$4(mockRpc);
+  return mockRpc;
+};
+
+const ExtensionHost = {
+  __proto__: null,
+  dispose: dispose$3,
+  executeFileReferenceProvider,
+  executeReferenceProvider,
+  getRuntimeStatus,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$1,
+  registerMockRpc: registerMockRpc$1,
+  set: set$4
+};
+
+const {
+  invoke: invoke$2,
   invokeAndTransfer,
-  set: set$2,
+  set: set$3,
   dispose: dispose$2
 } = create$1(RendererWorker$1);
 const searchFileHtml = async uri => {
-  return invoke$1('ExtensionHost.searchFileWithHtml', uri);
+  return invoke$2('ExtensionHost.searchFileWithHtml', uri);
 };
 const getFilePathElectron = async file => {
-  return invoke$1('FileSystemHandle.getFilePathElectron', file);
+  return invoke$2('FileSystemHandle.getFilePathElectron', file);
 };
 const showContextMenu$1 = async (x, y, id, ...args) => {
-  return invoke$1('ContextMenu.show', x, y, id, ...args);
+  return invoke$2('ContextMenu.show', x, y, id, ...args);
 };
 const getElectronVersion = async () => {
-  return invoke$1('Process.getElectronVersion');
+  return invoke$2('Process.getElectronVersion');
 };
 const applyBulkReplacement = async bulkEdits => {
-  await invoke$1('BulkReplacement.applyBulkReplacement', bulkEdits);
+  await invoke$2('BulkReplacement.applyBulkReplacement', bulkEdits);
 };
 const setColorTheme = async id => {
   // @ts-ignore
-  return invoke$1(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+  return invoke$2(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
 };
 const getNodeVersion = async () => {
-  return invoke$1('Process.getNodeVersion');
+  return invoke$2('Process.getNodeVersion');
 };
 const getChromeVersion = async () => {
-  return invoke$1('Process.getChromeVersion');
+  return invoke$2('Process.getChromeVersion');
 };
 const getV8Version = async () => {
-  return invoke$1('Process.getV8Version');
+  return invoke$2('Process.getV8Version');
 };
 const getFileHandles = async fileIds => {
-  const files = await invoke$1('FileSystemHandle.getFileHandles', fileIds);
+  const files = await invoke$2('FileSystemHandle.getFileHandles', fileIds);
   return files;
 };
 const setWorkspacePath = async path => {
-  await invoke$1('Workspace.setPath', path);
+  await invoke$2('Workspace.setPath', path);
 };
 const registerWebViewInterceptor = async (id, port) => {
   await invokeAndTransfer('WebView.registerInterceptor', id, port);
 };
 const unregisterWebViewInterceptor = async id => {
-  await invoke$1('WebView.unregisterInterceptor', id);
+  await invoke$2('WebView.unregisterInterceptor', id);
 };
 const sendMessagePortToEditorWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
@@ -1440,43 +1607,43 @@ const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
 const readFile = async uri => {
-  return invoke$1('FileSystem.readFile', uri);
+  return invoke$2('FileSystem.readFile', uri);
 };
 const getWebViewSecret = async key => {
   // @ts-ignore
-  return invoke$1('WebView.getSecret', key);
+  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$1('Focus.setFocus', key);
+  return invoke$2('Focus.setFocus', key);
 };
 const getFileIcon = async options => {
-  return invoke$1('IconTheme.getFileIcon', options);
+  return invoke$2('IconTheme.getFileIcon', options);
 };
 const getColorThemeNames = async () => {
-  return invoke$1('ColorTheme.getColorThemeNames');
+  return invoke$2('ColorTheme.getColorThemeNames');
 };
 const disableExtension = async id => {
   // @ts-ignore
-  return invoke$1('ExtensionManagement.disable', id);
+  return invoke$2('ExtensionManagement.disable', id);
 };
 const enableExtension = async id => {
   // @ts-ignore
-  return invoke$1('ExtensionManagement.enable', id);
+  return invoke$2('ExtensionManagement.enable', id);
 };
 const handleDebugChange = async params => {
   // @ts-ignore
-  return invoke$1('Run And Debug.handleChange', params);
+  return invoke$2('Run And Debug.handleChange', params);
 };
 const getFolderIcon = async options => {
-  return invoke$1('IconTheme.getFolderIcon', options);
+  return invoke$2('IconTheme.getFolderIcon', options);
 };
 const closeWidget = async widgetId => {
-  return invoke$1('Viewlet.closeWidget', widgetId);
+  return invoke$2('Viewlet.closeWidget', widgetId);
 };
-const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
+const sendMessagePortToExtensionHostWorker$2 = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
 };
@@ -1485,55 +1652,55 @@ const sendMessagePortToSearchProcess = async port => {
 };
 const confirm = async (message, options) => {
   // @ts-ignore
-  const result = await invoke$1('ConfirmPrompt.prompt', message, options);
+  const result = await invoke$2('ConfirmPrompt.prompt', message, options);
   return result;
 };
 const getRecentlyOpened = async () => {
-  return invoke$1(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+  return invoke$2(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
 };
 const getKeyBindings$1 = async () => {
-  return invoke$1('KeyBindingsInitial.getKeyBindings');
+  return invoke$2('KeyBindingsInitial.getKeyBindings');
 };
 const writeClipBoardText = async text => {
-  await invoke$1('ClipBoard.writeText', /* text */text);
+  await invoke$2('ClipBoard.writeText', /* text */text);
 };
 const writeClipBoardImage = async blob => {
   // @ts-ignore
-  await invoke$1('ClipBoard.writeImage', /* text */blob);
+  await invoke$2('ClipBoard.writeImage', /* text */blob);
 };
 const searchFileMemory = async uri => {
   // @ts-ignore
-  return invoke$1('ExtensionHost.searchFileWithMemory', uri);
+  return invoke$2('ExtensionHost.searchFileWithMemory', uri);
 };
 const searchFileFetch = async uri => {
-  return invoke$1('ExtensionHost.searchFileWithFetch', uri);
+  return invoke$2('ExtensionHost.searchFileWithFetch', uri);
 };
 const showMessageBox = async options => {
-  return invoke$1('ElectronDialog.showMessageBox', options);
+  return invoke$2('ElectronDialog.showMessageBox', options);
 };
 const handleDebugResumed = async params => {
-  await invoke$1('Run And Debug.handleResumed', params);
+  await invoke$2('Run And Debug.handleResumed', params);
 };
 const openWidget = async name => {
-  await invoke$1('Viewlet.openWidget', name);
+  await invoke$2('Viewlet.openWidget', name);
 };
 const getIcons = async requests => {
-  const icons = await invoke$1('IconTheme.getIcons', requests);
+  const icons = await invoke$2('IconTheme.getIcons', requests);
   return icons;
 };
 const activateByEvent = event => {
-  return invoke$1('ExtensionHostManagement.activateByEvent', event);
+  return invoke$2('ExtensionHostManagement.activateByEvent', event);
 };
 const setAdditionalFocus = focusKey => {
   // @ts-ignore
-  return invoke$1('Focus.setAdditionalFocus', focusKey);
+  return invoke$2('Focus.setAdditionalFocus', focusKey);
 };
 const getActiveEditorId = () => {
   // @ts-ignore
-  return invoke$1('GetActiveEditor.getActiveEditorId');
+  return invoke$2('GetActiveEditor.getActiveEditorId');
 };
 const getWorkspacePath = () => {
-  return invoke$1('Workspace.getPath');
+  return invoke$2('Workspace.getPath');
 };
 const sendMessagePortToRendererProcess = async port => {
   const command = 'HandleMessagePort.handleMessagePort';
@@ -1541,20 +1708,20 @@ const sendMessagePortToRendererProcess = async port => {
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
 };
 const getPreference = async key => {
-  return await invoke$1('Preferences.get', key);
+  return await invoke$2('Preferences.get', key);
 };
 const getAllExtensions$2 = async () => {
-  return invoke$1('ExtensionManagement.getAllExtensions');
+  return invoke$2('ExtensionManagement.getAllExtensions');
 };
 const rerenderEditor = async key => {
   // @ts-ignore
-  return invoke$1('Editor.rerender', key);
+  return invoke$2('Editor.rerender', key);
 };
 const handleDebugPaused = async params => {
-  await invoke$1('Run And Debug.handlePaused', params);
+  await invoke$2('Run And Debug.handlePaused', params);
 };
 const openUri$2 = async (uri, focus, options) => {
-  await invoke$1('Main.openUri', uri, focus, options);
+  await invoke$2('Main.openUri', uri, focus, options);
 };
 const sendMessagePortToSyntaxHighlightingWorker = async port => {
   await invokeAndTransfer(
@@ -1562,82 +1729,82 @@ const sendMessagePortToSyntaxHighlightingWorker = async port => {
   'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
 };
 const handleDebugScriptParsed = async script => {
-  await invoke$1('Run And Debug.handleScriptParsed', script);
+  await invoke$2('Run And Debug.handleScriptParsed', script);
 };
 const getWindowId = async () => {
-  return invoke$1('GetWindowId.getWindowId');
+  return invoke$2('GetWindowId.getWindowId');
 };
 const getBlob = async uri => {
   // @ts-ignore
-  return invoke$1('FileSystem.getBlob', uri);
+  return invoke$2('FileSystem.getBlob', uri);
 };
 const getExtensionCommands = async () => {
-  return invoke$1('ExtensionHost.getCommands');
+  return invoke$2('ExtensionHost.getCommands');
 };
 const showErrorDialog = async errorInfo => {
   // @ts-ignore
-  await invoke$1('ErrorHandling.showErrorDialog', errorInfo);
+  await invoke$2('ErrorHandling.showErrorDialog', errorInfo);
 };
 const getFolderSize = async uri => {
   // @ts-ignore
-  return await invoke$1('FileSystem.getFolderSize', uri);
+  return await invoke$2('FileSystem.getFolderSize', uri);
 };
 const getExtension = async id => {
   // @ts-ignore
-  return invoke$1('ExtensionManagement.getExtension', id);
+  return invoke$2('ExtensionManagement.getExtension', id);
 };
 const getMarkdownDom = async html => {
   // @ts-ignore
-  return invoke$1('Markdown.getVirtualDom', html);
+  return invoke$2('Markdown.getVirtualDom', html);
 };
 const renderMarkdown = async (markdown, options) => {
   // @ts-ignore
-  return invoke$1('Markdown.renderMarkdown', markdown, options);
+  return invoke$2('Markdown.renderMarkdown', markdown, options);
 };
 const openNativeFolder = async uri => {
   // @ts-ignore
-  await invoke$1('OpenNativeFolder.openNativeFolder', uri);
+  await invoke$2('OpenNativeFolder.openNativeFolder', uri);
 };
 const uninstallExtension = async id => {
-  return invoke$1('ExtensionManagement.uninstall', id);
+  return invoke$2('ExtensionManagement.uninstall', id);
 };
 const installExtension = async id => {
   // @ts-ignore
-  return invoke$1('ExtensionManagement.install', id);
+  return invoke$2('ExtensionManagement.install', id);
 };
 const openExtensionSearch = async () => {
   // @ts-ignore
-  return invoke$1('SideBar.openViewlet', 'Extensions');
+  return invoke$2('SideBar.openViewlet', 'Extensions');
 };
 const setExtensionsSearchValue = async searchValue => {
   // @ts-ignore
-  return invoke$1('Extensions.handleInput', searchValue);
+  return invoke$2('Extensions.handleInput', searchValue);
 };
 const openExternal = async uri => {
   // @ts-ignore
-  await invoke$1('Open.openExternal', uri);
+  await invoke$2('Open.openExternal', uri);
 };
 const openUrl = async uri => {
   // @ts-ignore
-  await invoke$1('Open.openUrl', uri);
+  await invoke$2('Open.openUrl', uri);
 };
 const getAllPreferences = async () => {
   // @ts-ignore
-  return invoke$1('Preferences.getAll');
+  return invoke$2('Preferences.getAll');
 };
 const showSaveFilePicker = async () => {
   // @ts-ignore
-  return invoke$1('FilePicker.showSaveFilePicker');
+  return invoke$2('FilePicker.showSaveFilePicker');
 };
 const getLogsDir = async () => {
   // @ts-ignore
-  return invoke$1('PlatformPaths.getLogsDir');
+  return invoke$2('PlatformPaths.getLogsDir');
 };
 const registerMockRpc = commandMap => {
   const mockRpc = createMockRpc({
     commandMap
   });
-  set$2(mockRpc);
+  set$3(mockRpc);
   return mockRpc;
 };
 
@@ -1680,7 +1847,7 @@ const RendererWorker = {
   handleDebugResumed,
   handleDebugScriptParsed,
   installExtension,
-  invoke: invoke$1,
+  invoke: invoke$2,
   invokeAndTransfer,
   openExtensionSearch,
   openExternal,
@@ -1698,14 +1865,14 @@ const RendererWorker = {
   searchFileMemory,
   sendMessagePortToEditorWorker,
   sendMessagePortToErrorWorker,
-  sendMessagePortToExtensionHostWorker,
+  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$2,
   sendMessagePortToFileSystemWorker,
   sendMessagePortToIconThemeWorker,
   sendMessagePortToMarkdownWorker,
   sendMessagePortToRendererProcess,
   sendMessagePortToSearchProcess,
   sendMessagePortToSyntaxHighlightingWorker,
-  set: set$2,
+  set: set$3,
   setAdditionalFocus,
   setColorTheme,
   setExtensionsSearchValue,
@@ -1722,15 +1889,23 @@ const RendererWorker = {
   writeClipBoardText
 };
 
-const copyExtensionId = async state => {
+const getFocusedItem = state => {
   const {
     items,
     focusedIndex
   } = state;
   if (focusedIndex === -1) {
-    return state;
+    return undefined;
   }
   const item = items[focusedIndex];
+  return item;
+};
+
+const copyExtensionId = async state => {
+  const item = getFocusedItem(state);
+  if (!item) {
+    return state;
+  }
   const {
     id
   } = item;
@@ -1779,14 +1954,10 @@ const getExtensionInfoText = extension => {
 };
 
 const copyExtensionInfo = async state => {
-  const {
-    items,
-    focusedIndex
-  } = state;
-  if (focusedIndex === -1) {
+  const item = getFocusedItem(state);
+  if (!item) {
     return state;
   }
-  const item = items[focusedIndex];
   const text = getExtensionInfoText(item);
   await writeClipBoardText(text);
   return state;
@@ -1794,9 +1965,11 @@ const copyExtensionInfo = async state => {
 
 const {
   get,
-  set: set$1,
+  set: set$2,
   dispose: dispose$1,
   wrapCommand,
+  getCommandIds,
+  registerCommands,
   wrapGetter
 } = create$2();
 
@@ -1833,7 +2006,7 @@ const create = (id, uri, x, y, width, height, platform, assetDir) => {
     x,
     y
   };
-  set$1(id, state, state);
+  set$2(id, state, state);
 };
 
 const isEqual$2 = (oldState, newState) => {
@@ -2068,18 +2241,6 @@ const getActions = () => {
   }];
 };
 
-const commandMapRef = {};
-
-const toCommandId = key => {
-  const dotIndex = key.indexOf('.');
-  return key.slice(dotIndex + 1);
-};
-const getCommandIds = () => {
-  const keys = Object.keys(commandMapRef);
-  const ids = keys.map(toCommandId);
-  return ids;
-};
-
 const Enter = 3;
 const Space = 9;
 const PageUp = 10;
@@ -2181,10 +2342,11 @@ const getExtensionDetailUri = extensionId => {
 };
 
 const {
-  invoke,
-  set,
+  invoke: invoke$1,
+  set: set$1,
   showContextMenu,
-  openUri: openUri$1
+  openUri: openUri$1,
+  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1
 } = RendererWorker;
 
 const openUri = async uri => {
@@ -2431,16 +2593,50 @@ const handleWheel = (state, deltaMode, deltaY) => {
   return setDeltaY(state, state.deltaY + deltaY);
 };
 
+const sendMessagePortToExtensionHostWorker = async port => {
+  await sendMessagePortToExtensionHostWorker$1(port, 0);
+};
+
+const createExtensionHostWorkerRpc = async () => {
+  try {
+    const rpc = await TransferMessagePortRpcParent.create({
+      commandMap: {},
+      send: sendMessagePortToExtensionHostWorker
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create extension host rpc`);
+  }
+};
+
+const {
+  set,
+  invoke} = ExtensionHost;
+
+const initializeExtensionHostWorker = async () => {
+  const rpc = await createExtensionHostWorkerRpc();
+  set(rpc);
+};
+
+const initialize = async () => {
+  await initializeExtensionHostWorker();
+};
+
 const Web = 1;
 const Electron = 2;
 const Remote = 3;
 
 const getAllExtensions$1 = async platform => {
   if (platform === Web) {
-    return [];
+    try {
+      const extensions = await invoke('Extensions.getExtensions');
+      return extensions;
+    } catch {
+      return [];
+    }
   }
   // @ts-ignore todo
-  return invoke('ExtensionManagement.getAllExtensions');
+  return invoke$1('ExtensionManagement.getAllExtensions');
 };
 
 const getAllExtensions = platform => {
@@ -3062,7 +3258,7 @@ const render3 = (uid, diffResult) => {
     oldState,
     newState
   } = get(uid);
-  set$1(uid, newState, newState);
+  set$2(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -3193,6 +3389,8 @@ const toggleSuggest = state => {
 const commandMap = {
   'SearchExtensions.clearSearchResults': wrapCommand(clearSearchResults),
   'SearchExtensions.closeSuggest': wrapCommand(closeSuggest),
+  'SearchExtensions.copyExtensionId': wrapCommand(copyExtensionId),
+  'SearchExtensions.copyExtensionInfo': wrapCommand(copyExtensionInfo),
   'SearchExtensions.create': create,
   'SearchExtensions.diff2': diff2,
   'SearchExtensions.dispose': dispose,
@@ -3201,14 +3399,13 @@ const commandMap = {
   'SearchExtensions.focusLast': wrapCommand(focusLast),
   'SearchExtensions.focusNext': wrapCommand(focusNext),
   'SearchExtensions.focusNextPage': wrapCommand(focusNextPage),
-  'SearchExtensions.focusPreviousPage': wrapCommand(focusPreviousPage),
   'SearchExtensions.focusPrevious': wrapCommand(focusPrevious),
+  'SearchExtensions.focusPreviousPage': wrapCommand(focusPreviousPage),
   'SearchExtensions.getActions': getActions,
   'SearchExtensions.getCommandIds': getCommandIds,
   'SearchExtensions.getKeyBindings': getKeyBindings,
   'SearchExtensions.getMenuEntries': getMenuEntries,
   'SearchExtensions.handleBlur': wrapCommand(handleBlur),
-  'SearchExtensions.copyExtensionInfo': wrapCommand(copyExtensionInfo),
   'SearchExtensions.handleClick': wrapCommand(handleClick),
   'SearchExtensions.handleClickAt': wrapCommand(handleClickAt),
   'SearchExtensions.handleClickCurrent': wrapCommand(handleClickCurrent),
@@ -3225,9 +3422,9 @@ const commandMap = {
   'SearchExtensions.handleScrollBarThumbPointerMove': wrapCommand(handleScrollBarMove),
   'SearchExtensions.handleUninstall': wrapCommand(handleUninstall),
   'SearchExtensions.handleWheel': wrapCommand(handleWheel),
+  'SearchExtensions.initialize': initialize,
   'SearchExtensions.loadContent': wrapCommand(loadContent),
   'SearchExtensions.openSuggest': wrapCommand(openSuggest),
-  'SearchExtensions.copyExtensionId': wrapCommand(copyExtensionId),
   'SearchExtensions.render3': render3,
   'SearchExtensions.renderActions': renderActions,
   'SearchExtensions.renderEventListeners': renderEventListeners,
@@ -3242,11 +3439,11 @@ const commandMap = {
 };
 
 const listen = async () => {
-  Object.assign(commandMapRef, commandMap);
+  registerCommands(commandMap);
   const rpc = await WebWorkerRpcClient.create({
-    commandMap: commandMapRef
+    commandMap: commandMap
   });
-  set(rpc);
+  set$1(rpc);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-search-view",
-  "version": "4.4.0",
+  "version": "4.6.0",
   "description": "Extension Search View Worker",
   "repository": {
     "type": "git",