@lvce-editor/extension-search-view 4.13.0 → 5.1.0

package/dist/extensionSearchViewWorkerMain.js

@@ -1066,10 +1066,11 @@ const create$2 = () => {
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
         const {
+          oldState,
           newState
         } = states[uid];
         const newerState = await fn(newState, ...args);
-        if (newState === newerState) {
+        if (oldState === newerState || newState === newerState) {
           return;
         }
         const latest = states[uid];
@@ -1134,11 +1135,13 @@ const TargetValue = 'event.target.value';
 
 const Script$1 = 2;
 
+const ManageExtension$1 = 8;
+
 const LeftClick = 0;
 
 const DebugWorker = 55;
 const ExtensionHostWorker = 44;
-const RendererWorker$2 = 1;
+const RendererWorker$1 = 1;
 
 const None$2 = 0;
 const Input = 1;
@@ -1266,17 +1269,17 @@ const Ellipsis = 'Ellipsis';
 const getInputActions = hasValue => {
   const clearEnabled = hasValue;
   const actions = [{
-    onClick: HandleClearSearchResults,
+    enabled: clearEnabled,
     icon: `MaskIcon${ClearAll}`,
+    onClick: HandleClearSearchResults,
     title: clearExtensionSearchResults(),
-    type: Button,
-    enabled: clearEnabled
+    type: Button
   }, {
+    enabled: true,
     icon: `MaskIcon${Filter}`,
-    title: filter(),
-    type: Button,
     onClick: HandleClickFilter,
-    enabled: true
+    title: filter(),
+    type: Button
   }];
   return actions;
 };
@@ -1380,16 +1383,16 @@ const parseValue = value => {
   });
   const isLocal = enabled || builtin || disabled || outdated || installed;
   return {
-    query: replaced,
-    enabled,
     builtin,
+    category,
     disabled,
-    outdated,
-    installed,
+    enabled,
     id,
-    sort,
+    installed,
     isLocal,
-    category
+    outdated,
+    query: replaced,
+    sort
   };
 };
 
@@ -1470,12 +1473,12 @@ const handleChange = async (state, update) => {
     const inputActions = getInputActions(hasValue);
     const {
       allExtensions,
+      assetDir,
+      headerHeight,
+      height,
       itemHeight,
       minimumSliderSize,
-      height,
-      platform,
-      assetDir,
-      headerHeight
+      platform
     } = state;
     // TODO cancel ongoing requests
     // TODO handle errors
@@ -1487,15 +1490,15 @@ const handleChange = async (state, update) => {
         deltaY: 0,
         finalDeltaY: 0,
         focus: Input,
+        inputActions,
+        inputSource,
         items,
         maxLineY: 0,
         message: noExtensionsFound(),
         minLineY: 0,
         placeholder: searchExtensionsInMarketPlace(),
         scrollBarHeight: 0,
-        searchValue: value,
-        inputSource,
-        inputActions
+        searchValue: value
       };
     }
     const total = items.length;
@@ -1511,6 +1514,8 @@ const handleChange = async (state, update) => {
       allExtensions,
       deltaY: 0,
       finalDeltaY,
+      inputActions,
+      inputSource,
       items,
       maxLineY,
       message: '',
@@ -1518,9 +1523,7 @@ const handleChange = async (state, update) => {
       placeholder: searchExtensionsInMarketPlace(),
       scrollBarHeight,
       scrollBarY,
-      searchValue: value,
-      inputSource,
-      inputActions
+      searchValue: value
     };
 
     // TODO handle out of order responses (a bit complicated)
@@ -1539,8 +1542,8 @@ const clearSearchResults = state => {
   return handleChange(state, {
     ...state,
     focus: Input,
-    searchValue: '',
-    inputSource: Script$1
+    inputSource: Script$1,
+    searchValue: ''
   });
 };
 
@@ -1623,19 +1626,23 @@ const {
   invokeAndTransfer,
   set: set$3,
   dispose: dispose$2
-} = create$1(RendererWorker$2);
+} = 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$1 = async (x, y, id, ...args) => {
+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 RendererWorker.invoke('ContextMenu.show2', uid, menuId, x, y, args);
+  await invoke$2('ContextMenu.show2', uid, menuId, x, y, args);
 };
 const getElectronVersion = async () => {
   return invoke$2('Process.getElectronVersion');
@@ -1752,6 +1759,9 @@ const getKeyBindings$1 = async () => {
 const writeClipBoardText = async text => {
   await invoke$2('ClipBoard.writeText', /* text */text);
 };
+const readClipBoardText = async () => {
+  return invoke$2('ClipBoard.readText');
+};
 const writeClipBoardImage = async blob => {
   // @ts-ignore
   await invoke$2('ClipBoard.writeImage', /* text */blob);
@@ -1795,6 +1805,16 @@ const sendMessagePortToRendererProcess = async port => {
   // @ts-ignore
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
 };
+const sendMessagePortToTextMeasurementWorker = async port => {
+  const command = 'TextMeasurement.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
+};
+const sendMessagePortToSourceControlWorker = async port => {
+  const command = 'SourceControl.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker', port, command, 0);
+};
 const getPreference = async key => {
   return await invoke$2('Preferences.get', key);
 };
@@ -1896,7 +1916,7 @@ const registerMockRpc = commandMap => {
   return mockRpc;
 };
 
-const RendererWorker$1 = {
+const RendererWorker = {
   __proto__: null,
   activateByEvent,
   applyBulkReplacement,
@@ -1943,6 +1963,7 @@ const RendererWorker$1 = {
   openUri: openUri$2,
   openUrl,
   openWidget,
+  readClipBoardText,
   readFile,
   registerMockRpc,
   registerWebViewInterceptor,
@@ -1959,7 +1980,9 @@ const RendererWorker$1 = {
   sendMessagePortToMarkdownWorker,
   sendMessagePortToRendererProcess,
   sendMessagePortToSearchProcess,
+  sendMessagePortToSourceControlWorker,
   sendMessagePortToSyntaxHighlightingWorker,
+  sendMessagePortToTextMeasurementWorker,
   set: set$3,
   setAdditionalFocus,
   setColorTheme,
@@ -1967,7 +1990,7 @@ const RendererWorker$1 = {
   setFocus,
   setWebViewPort,
   setWorkspacePath,
-  showContextMenu: showContextMenu$1,
+  showContextMenu,
   showContextMenu2,
   showErrorDialog,
   showMessageBox,
@@ -1980,8 +2003,8 @@ const RendererWorker$1 = {
 
 const getFocusedItem = state => {
   const {
-    items,
-    focusedIndex
+    focusedIndex,
+    items
   } = state;
   if (focusedIndex === -1) {
     return undefined;
@@ -2011,10 +2034,10 @@ const stringifyRow = row => {
 };
 const getExtensionInfoText = extension => {
   const {
-    name: name$1,
+    description: description$1,
     id: id$1,
-    publisher: publisher$1,
-    description: description$1
+    name: name$1,
+    publisher: publisher$1
   } = extension;
   const version$1 = ''; // TODO
   const marketplaceLink$1 = ''; // TODO
@@ -2053,14 +2076,14 @@ const copyExtensionInfo = async state => {
 };
 
 const {
-  get,
-  set: set$2,
+  diff,
   dispose: dispose$1,
-  wrapCommand,
+  get,
   getCommandIds,
   registerCommands,
-  wrapGetter,
-  diff
+  set: set$2,
+  wrapCommand,
+  wrapGetter
 } = create$2();
 
 const create = (id, uri, x, y, width, height, platform, assetDir) => {
@@ -2308,15 +2331,15 @@ const focusPreviousPage = state => {
 
 const getActions = () => {
   return [{
-    type: Button,
-    id: refresh(),
+    command: '',
     icon: Refresh,
-    command: ''
+    id: refresh(),
+    type: Button
   }, {
-    type: Button,
-    id: viewsAndMoreActions(),
+    command: '',
     icon: Ellipsis,
-    command: ''
+    id: viewsAndMoreActions(),
+    type: Button
   }];
 };
 
@@ -2336,44 +2359,44 @@ const FocusExtensionsInput = 7000;
 
 const getKeyBindings = () => {
   return [{
-    key: Home,
     command: 'Extensions.focusFirst',
+    key: Home,
     when: FocusExtensions
   }, {
-    key: End,
     command: 'Extensions.focusLast',
+    key: End,
     when: FocusExtensions
   }, {
-    key: PageUp,
     command: 'Extensions.focusPreviousPage',
+    key: PageUp,
     when: FocusExtensions
   }, {
-    key: PageDown,
     command: 'Extensions.focusNextPage',
+    key: PageDown,
     when: FocusExtensions
   }, {
-    key: UpArrow,
     command: 'Extensions.focusPrevious',
+    key: UpArrow,
     when: FocusExtensions
   }, {
-    key: DownArrow,
     command: 'Extensions.focusNext',
+    key: DownArrow,
     when: FocusExtensions
   }, {
-    key: Space,
     command: 'Extensions.handleClickCurrentButKeepFocus',
+    key: Space,
     when: FocusExtensions
   }, {
-    key: Enter,
     command: 'Extensions.handleClickCurrent',
+    key: Enter,
     when: FocusExtensions
   }, {
-    key: CtrlCmd | Space,
     command: 'Extensions.toggleSuggest',
+    key: CtrlCmd | Space,
     when: FocusExtensions
   }, {
-    key: CtrlCmd | DownArrow,
     command: 'Extensions.scrollDown',
+    key: CtrlCmd | DownArrow,
     when: FocusExtensions
   }];
 };
@@ -2382,33 +2405,41 @@ const None$1 = 0;
 
 const getMenuEntries = () => {
   return [{
-    id: 'enable',
-    label: enable(),
+    command: 'SearchExtensions.enable',
     flags: None$1,
-    command: 'SearchExtensions.enable'
+    id: 'enable',
+    label: enable()
   }, {
-    id: 'disable',
-    label: disable(),
+    command: 'SearchExtensions.disable',
     flags: None$1,
-    command: 'SearchExtensions.disable'
+    id: 'disable',
+    label: disable()
   }, {
-    id: 'installAnotherVersion',
-    label: installAnotherVersion(),
+    command: 'SearchExtensions.installAnotherVersion',
     flags: None$1,
-    command: 'SearchExtensions.installAnotherVersion'
+    id: 'installAnotherVersion',
+    label: installAnotherVersion()
   }, {
-    id: 'copy',
-    label: copy(),
+    command: 'Extensions.copyExtensionInfo',
     flags: None$1,
-    command: 'Extensions.copyExtensionInfo'
+    id: 'copy',
+    label: copy()
   }, {
-    id: 'copyExtensionId',
-    label: copyExtensionId$1(),
+    command: 'Extensions.copyExtensionId',
     flags: None$1,
-    command: 'Extensions.copyExtensionId'
+    id: 'copyExtensionId',
+    label: copyExtensionId$1()
   }];
 };
 
+const getMenuEntries2 = state => {
+  return getMenuEntries();
+};
+
+const getMenuIds = () => {
+  return [ManageExtension$1];
+};
+
 const handleBlur = state => {
   return {
     ...state,
@@ -2422,11 +2453,9 @@ const getExtensionDetailUri = extensionId => {
 
 const {
   invoke: invoke$1,
-  set: set$1,
-  showContextMenu,
   openUri: openUri$1,
-  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1
-} = RendererWorker$1;
+  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
+  set: set$1} = RendererWorker;
 
 const openUri = async uri => {
   return openUri$1(uri);
@@ -2473,11 +2502,11 @@ const handleClickAt = async (state, button, eventX, eventY) => {
     return state;
   }
   const {
-    x,
-    y,
-    itemHeight,
     deltaY,
-    headerHeight
+    headerHeight,
+    itemHeight,
+    x,
+    y
   } = state;
   const index = getListIndex(eventX, eventY, x, y, deltaY, itemHeight, headerHeight);
   return handleClick(state, index);
@@ -2497,18 +2526,20 @@ const handleClickCurrentButKeepFocus = state => {
   return handleClick(state, focusedIndex);
 };
 
-const show = async (x, y, id) => {
-  number(x);
-  number(y);
-  number(id);
-  await showContextMenu(x, y, id);
+const show2 = async (uid, menuId, x, y, args) => {
+  await showContextMenu2(uid, menuId, x, y, args);
 };
 
 const ManageExtension = 8;
 
 const handleContextMenu = async (state, button, x, y) => {
   // TODO use focused index when when context menu button is -1 (keyboard)
-  await show(x, y, ManageExtension);
+  const {
+    uid
+  } = state;
+  await show2(uid, ManageExtension, x, y, {
+    menuId: ManageExtension
+  });
   return state;
 };
 
@@ -2534,8 +2565,8 @@ const handleHeaderContextMenu = async state => {
 
 const handleInput = async (state, value, inputSource = User) => {
   return handleChange(state, {
-    searchValue: value,
-    inputSource
+    inputSource,
+    searchValue: value
   });
 };
 
@@ -2557,21 +2588,21 @@ const getNewDeltaPercent = (height, scrollBarHeight, relativeY) => {
   if (relativeY <= halfScrollBarHeight) {
     // clicked at top
     return {
-      percent: 0,
-      handleOffset: relativeY
+      handleOffset: relativeY,
+      percent: 0
     };
   }
   if (relativeY <= height - halfScrollBarHeight) {
     // clicked in middle
     return {
-      percent: (relativeY - halfScrollBarHeight) / (height - scrollBarHeight),
-      handleOffset: halfScrollBarHeight
+      handleOffset: halfScrollBarHeight,
+      percent: (relativeY - halfScrollBarHeight) / (height - scrollBarHeight)
     };
   }
   // clicked at bottom
   return {
-    percent: 1,
-    handleOffset: scrollBarHeight - height + relativeY
+    handleOffset: scrollBarHeight - height + relativeY,
+    percent: 1
   };
 };
 
@@ -2586,11 +2617,11 @@ const setDeltaY = (state, value) => {
   object(state);
   number(value);
   const {
-    itemHeight,
-    finalDeltaY,
     deltaY,
-    height,
+    finalDeltaY,
     headerHeight,
+    height,
+    itemHeight,
     items,
     minimumSliderSize
   } = state;
@@ -2609,8 +2640,8 @@ const setDeltaY = (state, value) => {
   return {
     ...state,
     deltaY: newDeltaY,
-    minLineY,
     maxLineY,
+    minLineY,
     scrollBarY
   };
 };
@@ -2618,12 +2649,12 @@ const setDeltaY = (state, value) => {
 const handleScrollBarClick = (state, eventY) => {
   // TODO move this to list
   const {
-    y,
     deltaY,
-    headerHeight,
     finalDeltaY,
+    headerHeight,
+    height,
     scrollBarHeight,
-    height
+    y
   } = state;
   const contentHeight = height - headerHeight;
   const relativeY = eventY - y - headerHeight;
@@ -2637,8 +2668,8 @@ const handleScrollBarClick = (state, eventY) => {
     };
   }
   const {
-    percent,
-    handleOffset
+    handleOffset,
+    percent
   } = getNewDeltaPercent(contentHeight, scrollBarHeight, relativeY);
   const newDeltaY = percent * finalDeltaY;
   return {
@@ -2658,12 +2689,12 @@ const getNewPercent = (contentHeight, scrollBarHeight, relativeY) => {
 };
 const handleScrollBarMove = (state, eventY) => {
   const {
-    y,
-    headerHeight,
-    handleOffset,
     finalDeltaY,
+    handleOffset,
+    headerHeight,
     height,
-    scrollBarHeight
+    scrollBarHeight,
+    y
   } = state;
   const relativeY = eventY - y - headerHeight - handleOffset;
   const contentHeight = height - headerHeight;
@@ -2700,8 +2731,9 @@ const createExtensionHostWorkerRpc = async () => {
 };
 
 const {
-  set,
-  invoke} = ExtensionHost;
+  invoke,
+  set
+} = ExtensionHost;
 
 const initializeExtensionHostWorker = async () => {
   const rpc = await createExtensionHostWorkerRpc();
@@ -2843,13 +2875,13 @@ const getPublisher = extension => {
 
 const normalizeExtension$1 = (extension, platform, assetDir) => {
   return {
+    categories: getCategories(extension),
+    description: getDescription(extension),
+    icon: getIcon(extension, platform, assetDir),
     id: getId$1(extension),
     name: getName(extension),
-    description: getDescription(extension),
-    uri: '',
     publisher: getPublisher(extension),
-    icon: getIcon(extension, platform, assetDir),
-    categories: getCategories(extension)
+    uri: ''
   };
 };
 
@@ -2878,20 +2910,20 @@ const restoreState = savedState => {
   const searchValue = getSavedValue(savedState);
   const savedDeltaY = getSavedDeltaY(savedState);
   return {
-    searchValue,
-    deltaY: savedDeltaY
+    deltaY: savedDeltaY,
+    searchValue
   };
 };
 
 const loadContent = async (state, savedState) => {
   const {
-    width,
+    assetDir,
     platform,
-    assetDir
+    width
   } = state;
   const {
-    searchValue,
-    deltaY
+    deltaY,
+    searchValue
   } = restoreState(savedState);
   // TODO just get local extensions on demand (not when query string is already different)
   const allExtensions = await getAllExtensions(platform);
@@ -2900,9 +2932,9 @@ const loadContent = async (state, savedState) => {
   const updatedState = await handleInput({
     ...state,
     allExtensions: normalized,
-    size,
+    deltaY,
     inputSource: Script,
-    deltaY
+    size
   }, searchValue, Script);
   return updatedState;
 };
@@ -2925,8 +2957,8 @@ const getSelector = focus => {
 };
 const renderFocus = newState => {
   const {
-    uid,
-    focus
+    focus,
+    uid
   } = newState;
   if (!focus) {
     return [];
@@ -2990,56 +3022,56 @@ const getClassName$1 = enabled => {
 };
 const getSearchFieldButtonVirtualDom = button => {
   const {
-    icon,
-    title,
     enabled,
-    onClick
+    icon,
+    onClick,
+    title
   } = button;
   return [{
-    type: Button$2,
+    childCount: 1,
     className: getClassName$1(enabled),
-    title,
+    onClick,
     tabIndex: 0,
-    childCount: 1,
-    onClick
+    title,
+    type: Button$2
   }, {
-    type: Div,
+    childCount: 0,
     className: mergeClassNames(MaskIcon, icon),
-    childCount: 0
+    type: Div
   }];
 };
 
 const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, outsideButtons, onFocus = '') => {
   // TODO avoid mutation
   const dom = [{
-    type: Div,
+    childCount: 2,
     className: SearchField,
     role: None,
-    childCount: 2
+    type: Div
   }, {
-    type: Input$1,
-    inputType: 'search',
-    className: MultilineInputBox,
-    spellcheck: false,
     autocapitalize: 'off',
-    autocorrect: 'off',
     autocomplete: 'off',
-    placeholder,
+    autocorrect: 'off',
+    childCount: 0,
+    className: MultilineInputBox,
+    inputType: 'search',
     name,
-    onInput,
     onFocus,
-    childCount: 0
+    onInput,
+    placeholder,
+    spellcheck: false,
+    type: Input$1
   }, {
-    type: Div,
+    childCount: insideButtons.length,
     className: SearchFieldButtons,
-    childCount: insideButtons.length
+    type: Div
   }, ...insideButtons.flatMap(getSearchFieldButtonVirtualDom)];
   if (outsideButtons.length > 0) {
     dom.unshift({
-      type: Div,
+      childCount: 1 + outsideButtons.length,
       className: SearchFieldContainer,
       role: None,
-      childCount: 1 + outsideButtons.length
+      type: Div
     });
     dom.push(...outsideButtons.flatMap(getSearchFieldButtonVirtualDom));
   }
@@ -3047,10 +3079,10 @@ const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, out
 };
 
 const parentNode = {
-  type: Div,
-  className: ExtensionHeader,
   childCount: 1,
-  onContextMenu: HandleHeaderContextMenu
+  className: ExtensionHeader,
+  onContextMenu: HandleHeaderContextMenu,
+  type: Div
 };
 const getExtensionHeaderVirtualDom = (placeholder, actions) => {
   return [parentNode, ...getSearchFieldVirtualDom(Extensions$1, placeholder, HandleExtensionsInput, actions, [])];
@@ -3065,29 +3097,29 @@ const renderHeader = newState => {
 const Extension = 'Extension';
 
 const listItemDetail = {
-  type: Div,
+  childCount: 3,
   className: ExtensionListItemDetail,
-  childCount: 3
+  type: Div
 };
 const listItemName = {
-  type: Div,
+  childCount: 1,
   className: ExtensionListItemName,
-  childCount: 1
+  type: Div
 };
 const listItemDescription = {
-  type: Div,
+  childCount: 1,
   className: ExtensionListItemDescription,
-  childCount: 1
+  type: Div
 };
 const listItemFooter = {
-  type: Div,
+  childCount: 2,
   className: ExtensionListItemFooter,
-  childCount: 2
+  type: Div
 };
 const listItemAuthorName = {
-  type: Div,
+  childCount: 1,
   className: ExtensionListItemAuthorName,
-  childCount: 1
+  type: Div
 };
 const getClassName = focused => {
   if (focused) {
@@ -3103,46 +3135,44 @@ const getId = focused => {
 };
 const getExtensionListItemVirtualDom = extension => {
   const {
-    posInSet,
-    setSize,
-    top,
+    description,
+    focused,
     icon,
     name,
-    description,
+    posInSet,
     publisher,
-    focused
+    setSize,
+    top
   } = extension;
   const dom = [{
-    type: Div,
-    role: ListItem,
+    ariaPosInSet: posInSet,
     ariaRoleDescription: Extension,
+    ariaSetSize: setSize,
+    childCount: 2,
     className: getClassName(focused),
     id: getId(focused),
-    ariaPosInSet: posInSet,
-    ariaSetSize: setSize,
+    role: ListItem,
     top,
-    childCount: 2
+    type: Div
   }, {
-    type: Img,
-    src: icon,
+    childCount: 0,
     className: ExtensionListItemIcon,
     role: None,
-    childCount: 0
+    src: icon,
+    type: Img
   }, listItemDetail, listItemName, text(name), listItemDescription, text(description), listItemFooter, listItemAuthorName, text(publisher), {
-    type: Div,
+    childCount: 0,
     className: ExtensionActions,
-    childCount: 0
+    type: Div
   }];
   return dom;
 };
 
 const getExtensionsListVirtualDom = visibleExtensions => {
   const dom = [{
-    type: Div,
-    className: ListItems,
-    tabIndex: 0,
     ariaLabel: extensions(),
-    role: List,
+    childCount: visibleExtensions.length,
+    className: ListItems,
     onContextmenu: HandleContextMenu,
     onContextMenu: HandleContextMenu,
     onFocus: HandleFocus,
@@ -3151,7 +3181,9 @@ const getExtensionsListVirtualDom = visibleExtensions => {
     onTouchMove: HandleTouchMove,
     onTouchStart: HandleTouchStart,
     onWheel: HandleWheel,
-    childCount: visibleExtensions.length
+    role: List,
+    tabIndex: 0,
+    type: Div
   }, ...visibleExtensions.flatMap(getExtensionListItemVirtualDom)];
   return dom;
 };
@@ -3178,50 +3210,50 @@ const getScrollBarVirtualDom = (scrollBarHeight, scrollBarTop) => {
   const heightString = px(scrollBarHeight);
   const translateString = position(0, scrollBarTop);
   return [{
-    type: Div,
+    childCount: 1,
     className: mergeClassNames(ScrollBar, ScrollBarSmall),
     onPointerDown: HandleScrollBarPointerDown,
     // TODO support pointercapture event
-    childCount: 1
+    type: Div
   }, {
-    type: Div,
-    className: ScrollBarThumb,
     childCount: 0,
+    className: ScrollBarThumb,
     height: heightString,
-    translate: translateString
+    translate: translateString,
+    type: Div
   }];
 };
 
 const getVisibleItem = (item, setSize, itemHeight, minLineY, relative, i, focusedIndex) => {
   // TODO use normal parameters
   const {
-    publisher,
     description,
     icon,
     id,
-    name
+    name,
+    publisher
   } = item;
   return {
-    setSize,
-    posInSet: i + 1,
-    top: (i - minLineY) * itemHeight - relative,
-    focused: i === focusedIndex,
-    publisher,
     description,
+    focused: i === focusedIndex,
     icon,
     id,
-    name
+    name,
+    posInSet: i + 1,
+    publisher,
+    setSize,
+    top: (i - minLineY) * itemHeight - relative
   };
 };
 
 const getVisible = state => {
   const {
-    minLineY,
-    maxLineY,
-    items,
-    itemHeight,
     deltaY,
-    focusedIndex
+    focusedIndex,
+    itemHeight,
+    items,
+    maxLineY,
+    minLineY
   } = state;
   const setSize = items.length;
   const visible = [];
@@ -3236,32 +3268,32 @@ const getVisible = state => {
 const getContentVirtualDom = (visibleExtensions, message, scrollBarHeight, scrollBarY) => {
   if (message) {
     return [{
-      type: Div,
-      childCount: 1
+      childCount: 1,
+      type: Div
     }, text(message)];
   }
   return [{
-    type: Div,
+    childCount: 2,
     className: mergeClassNames(Viewlet, List$1),
-    childCount: 2
+    type: Div
   }, ...getExtensionsVirtualDom(visibleExtensions), ...getScrollBarVirtualDom(scrollBarHeight, scrollBarY)];
 };
 const getExtensionsViewVirtualDom = state => {
   const visibleExtensions = getVisible(state);
   const {
-    placeholder,
     inputActions,
     message,
+    placeholder,
     scrollBarHeight,
     scrollBarY
   } = state;
   return [{
-    type: Div,
-    className: mergeClassNames(Viewlet, Extensions),
-    childCount: 2,
-    ariaLive: 'polite',
     ariaBusy: false,
-    role: None$3
+    ariaLive: 'polite',
+    childCount: 2,
+    className: mergeClassNames(Viewlet, Extensions),
+    role: None$3,
+    type: Div
   }, ...getExtensionHeaderVirtualDom(placeholder, inputActions), ...getContentVirtualDom(visibleExtensions, message, scrollBarHeight, scrollBarY)];
 };
 
@@ -3299,6 +3331,12 @@ const renderSearchValue = newState => {
 
 const getRenderer = diffType => {
   switch (diffType) {
+    case RenderFocus:
+      return renderFocus;
+    case RenderFocusContext:
+      return renderFocusContext;
+    case RenderHeader:
+      return renderHeader;
     case RenderItems:
       return renderItems2;
     case RenderMessage:
@@ -3307,12 +3345,6 @@ const getRenderer = diffType => {
       return renderScrollBar;
     case RenderSearchValue:
       return renderSearchValue;
-    case RenderHeader:
-      return renderHeader;
-    case RenderFocus:
-      return renderFocus;
-    case RenderFocusContext:
-      return renderFocusContext;
     default:
       throw new Error('unknown renderer');
   }
@@ -3329,8 +3361,8 @@ const applyRender = (oldState, newState, diffResult) => {
 
 const render3 = (uid, diffResult) => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get(uid);
   set$2(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
@@ -3339,23 +3371,23 @@ const render3 = (uid, diffResult) => {
 
 const getIconVirtualDom = (icon, type = Div) => {
   return {
-    type,
+    childCount: 0,
     className: mergeClassNames(MaskIcon, `MaskIcon${icon}`),
     role: None,
-    childCount: 0
+    type
   };
 };
 
 const getActionButtonVirtualDom = action => {
   const {
-    id,
-    icon
+    icon,
+    id
   } = action;
   return [{
-    type: Button$2,
+    childCount: 1,
     className: IconButton,
     title: id,
-    childCount: 1
+    type: Button$2
   }, getIconVirtualDom(icon)];
 };
 
@@ -3370,17 +3402,17 @@ const getActionVirtualDom = action => {
 
 const getActionsVirtualDom = actions => {
   return [{
-    type: Div,
+    childCount: actions.length,
     className: Actions,
     role: ToolBar,
-    childCount: actions.length
+    type: Div
   }, ...actions.flatMap(getActionVirtualDom)];
 };
 
 const renderActions = uid => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get(uid);
   if (oldState === newState) {
     return [];
@@ -3435,16 +3467,16 @@ const renderEventListeners = () => {
 
 const resize = async (state, dimensions) => {
   const {
-    items,
-    itemHeight,
     headerHeight,
+    itemHeight,
+    items,
     minimumSliderSize
   } = state;
   const {
-    x,
-    y,
+    height,
     width,
-    height
+    x,
+    y
   } = dimensions;
   const total = items.length;
   const listHeight = getListHeight(total, itemHeight, height);
@@ -3469,19 +3501,19 @@ const resize = async (state, dimensions) => {
 
 const saveState = state => {
   const {
-    searchValue,
-    deltaY
+    deltaY,
+    searchValue
   } = state;
   return {
-    searchValue,
-    deltaY
+    deltaY,
+    searchValue
   };
 };
 
 const scrollDown = state => {
   const {
-    finalDeltaY,
-    deltaY
+    deltaY,
+    finalDeltaY
   } = state;
   const newDeltaY = Math.min(deltaY + 20, finalDeltaY);
   return setDeltaY(state, newDeltaY);
@@ -3510,7 +3542,6 @@ const commandMap = {
   'SearchExtensions.focusIndex': wrapCommand(focusIndex),
   'SearchExtensions.focusLast': wrapCommand(focusLast),
   'SearchExtensions.focusNext': wrapCommand(focusNext),
-  'SearchExtensions.handleHeaderContextMenu': wrapCommand(handleHeaderContextMenu),
   'SearchExtensions.focusNextPage': wrapCommand(focusNextPage),
   'SearchExtensions.focusPrevious': wrapCommand(focusPrevious),
   'SearchExtensions.focusPreviousPage': wrapCommand(focusPreviousPage),
@@ -3518,6 +3549,8 @@ const commandMap = {
   'SearchExtensions.getCommandIds': getCommandIds,
   'SearchExtensions.getKeyBindings': getKeyBindings,
   'SearchExtensions.getMenuEntries': getMenuEntries,
+  'SearchExtensions.getMenuEntries2': wrapGetter(getMenuEntries2),
+  'SearchExtensions.getMenuIds': getMenuIds,
   'SearchExtensions.handleBlur': wrapCommand(handleBlur),
   'SearchExtensions.handleClick': wrapCommand(handleClick),
   'SearchExtensions.handleClickAt': wrapCommand(handleClickAt),
@@ -3527,6 +3560,7 @@ const commandMap = {
   'SearchExtensions.handleDisable': wrapCommand(handleDisable),
   'SearchExtensions.handleEnable': wrapCommand(handleEnable),
   'SearchExtensions.handleFocus': wrapCommand(handleFocus),
+  'SearchExtensions.handleHeaderContextMenu': wrapCommand(handleHeaderContextMenu),
   'SearchExtensions.handleInput': wrapCommand(handleInput),
   'SearchExtensions.handleInstall': wrapCommand(handleInstall),
   'SearchExtensions.handleScrollBarCaptureLost': wrapCommand(handleScrollBarCaptureLost),
@@ -3541,6 +3575,7 @@ const commandMap = {
   'SearchExtensions.render3': render3,
   'SearchExtensions.renderActions': renderActions,
   'SearchExtensions.renderEventListeners': renderEventListeners,
+  'SearchExtensions.resize': wrapCommand(resize),
   'SearchExtensions.restoreState': restoreState,
   'SearchExtensions.saveState': wrapGetter(saveState),
   'SearchExtensions.scrollDown': wrapCommand(scrollDown),
@@ -3548,8 +3583,7 @@ const commandMap = {
   'SearchExtensions.selectIndex': wrapCommand(selectIndex),
   'SearchExtensions.setDeltaY': wrapCommand(setDeltaY),
   'SearchExtensions.terminate': terminate,
-  'SearchExtensions.toggleSuggest': wrapCommand(toggleSuggest),
-  'SearchExtensions.resize': wrapCommand(resize)
+  'SearchExtensions.toggleSuggest': wrapCommand(toggleSuggest)
 };
 
 const listen = async () => {

package/package.json

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