@vibe-forge/client 3.0.0-alpha.6 → 3.0.0

package/src/components/chat/sender/@core/content-attachments.ts

@@ -1,76 +0,0 @@
-import type { ChatMessageContent } from '@vibe-forge/core'
-
-import type { PendingContextFile, PendingImage, SenderComposerState } from '../@types/sender-composer'
-
-export const createPendingImageId = (index: number) => `pending-image-${index}`
-
-export const getInitialComposerState = (content: string | ChatMessageContent[] | undefined): SenderComposerState => {
-  if (typeof content === 'string') {
-    return {
-      input: content,
-      pendingImages: [],
-      pendingFiles: []
-    }
-  }
-
-  if (!Array.isArray(content)) {
-    return {
-      input: '',
-      pendingImages: [],
-      pendingFiles: []
-    }
-  }
-
-  const textItems = content
-    .filter((item): item is Extract<ChatMessageContent, { type: 'text' }> => item.type === 'text')
-    .map(item => item.text)
-  const imageItems = content
-    .filter((item): item is Extract<ChatMessageContent, { type: 'image' }> => item.type === 'image')
-    .map((item, index) => ({
-      id: createPendingImageId(index),
-      url: item.url,
-      name: item.name,
-      size: item.size,
-      mimeType: item.mimeType
-    }))
-  const fileItems = content
-    .filter((item): item is Extract<ChatMessageContent, { type: 'file' }> => item.type === 'file')
-    .map(item => ({
-      path: item.path,
-      name: item.name,
-      size: item.size
-    }))
-
-  return {
-    input: textItems.join('\n\n'),
-    pendingImages: imageItems,
-    pendingFiles: fileItems
-  }
-}
-
-export const buildMessageContent = (
-  input: string,
-  pendingImages: PendingImage[],
-  pendingFiles: PendingContextFile[]
-) => {
-  const content: ChatMessageContent[] = []
-  if (input.trim() !== '') {
-    content.push({ type: 'text', text: input.trim() })
-  }
-
-  content.push(...pendingImages.map((img): ChatMessageContent => ({
-    type: 'image',
-    url: img.url,
-    name: img.name,
-    size: img.size,
-    mimeType: img.mimeType
-  })))
-  content.push(...pendingFiles.map((file): ChatMessageContent => ({
-    type: 'file',
-    path: file.path,
-    name: file.name,
-    size: file.size
-  })))
-
-  return content
-}

package/src/components/chat/sender/@core/create-sender-toolbar-handlers.ts

@@ -1,142 +0,0 @@
-import type { ReactNode } from 'react'
-
-import type { ChatEffort } from '#~/hooks/chat/use-chat-effort'
-import type { ModelSelectOption } from '#~/hooks/chat/use-chat-model-adapter-selection'
-import type { PermissionMode } from '#~/hooks/chat/use-chat-permission-mode'
-import type { SessionQueuedMessageMode } from '@vibe-forge/core'
-
-import type { SenderToolbarHandlers } from '../@types/sender-toolbar-types'
-
-export const createSenderToolbarHandlers = ({
-  attachments,
-  canOpenReferenceActions,
-  focusRestore,
-  isInlineEdit,
-  message,
-  modelUnavailable,
-  onAdapterChange,
-  onAccountChange,
-  onEffortChange,
-  onInterrupt,
-  onModelChange,
-  onToggleRecommendedModel,
-  onPermissionModeChange,
-  onQueueModeChange,
-  onCancel,
-  onConfirmInteractionOption,
-  onSend,
-  referenceActions,
-  selectOverlays,
-  t
-}: {
-  attachments: {
-    handleImageFileChange: SenderToolbarHandlers['onImageFileChange']
-    handleImageUpload: () => void
-    handleOpenContextPicker: () => void
-  }
-  canOpenReferenceActions: boolean
-  focusRestore: { queueEditorFocusRestore: () => void }
-  isInlineEdit: boolean
-  message: { warning: (content: ReactNode) => unknown }
-  modelUnavailable?: boolean
-  onAdapterChange?: (adapter: string) => void
-  onAccountChange?: (account: string) => void
-  onEffortChange?: (effort: ChatEffort) => void
-  onInterrupt: () => void
-  onModelChange?: (model: string) => void
-  onToggleRecommendedModel?: (option: ModelSelectOption) => void | Promise<void>
-  onPermissionModeChange?: (mode: PermissionMode) => void
-  onQueueModeChange?: (mode: SessionQueuedMessageMode) => void
-  onCancel?: () => void
-  onConfirmInteractionOption?: () => void
-  onSend: (mode?: SessionQueuedMessageMode) => void
-  referenceActions: {
-    setShowReferenceActions: (nextOpen: boolean) => void
-    setShowPermissionActions: (nextOpen: boolean) => void
-    closeReferenceActions: (options?: { restoreFocus?: boolean }) => void
-    handleReferenceMenuKeyDown: SenderToolbarHandlers['onReferenceMenuKeyDown']
-    handlePermissionMenuKeyDown: SenderToolbarHandlers['onPermissionMenuKeyDown']
-  }
-  selectOverlays: {
-    setShowModelSelect: (nextOpen: boolean) => void
-    setShowEffortSelect: (nextOpen: boolean) => void
-    setModelSearchValue: (value: string) => void
-    openModelSelector: () => boolean
-    openEffortSelector: () => boolean
-  }
-  t: (key: string) => string
-}) => {
-  return {
-    onImageFileChange: attachments.handleImageFileChange,
-    onReferenceOpenChange: (nextOpen) => {
-      if (nextOpen && !canOpenReferenceActions) {
-        if (!isInlineEdit && modelUnavailable) {
-          void message.warning(t('chat.modelConfigRequired'))
-        }
-        return
-      }
-
-      selectOverlays.setShowModelSelect(false)
-      selectOverlays.setShowEffortSelect(false)
-
-      if (!nextOpen) {
-        referenceActions.closeReferenceActions({ restoreFocus: true })
-        return
-      }
-
-      referenceActions.setShowPermissionActions(false)
-      referenceActions.setShowReferenceActions(true)
-    },
-    onShowModelSelectChange: selectOverlays.setShowModelSelect,
-    onShowEffortSelectChange: selectOverlays.setShowEffortSelect,
-    onPermissionOpenChange: (nextOpen) => {
-      if (nextOpen && !canOpenReferenceActions) {
-        if (!isInlineEdit && modelUnavailable) {
-          void message.warning(t('chat.modelConfigRequired'))
-        }
-        return
-      }
-
-      if (!nextOpen) {
-        referenceActions.closeReferenceActions({ restoreFocus: true })
-        return
-      }
-
-      selectOverlays.setShowModelSelect(false)
-      selectOverlays.setShowEffortSelect(false)
-      referenceActions.setShowReferenceActions(false)
-      referenceActions.setShowPermissionActions(true)
-    },
-    onModelSearchValueChange: selectOverlays.setModelSearchValue,
-    onOpenContextPicker: attachments.handleOpenContextPicker,
-    onReferenceImageSelect: attachments.handleImageUpload,
-    onSelectPermissionMode: (mode) => {
-      onPermissionModeChange?.(mode)
-      referenceActions.closeReferenceActions({ restoreFocus: true })
-    },
-    onReferenceMenuKeyDown: referenceActions.handleReferenceMenuKeyDown,
-    onPermissionMenuKeyDown: referenceActions.handlePermissionMenuKeyDown,
-    onOpenModelSelector: () => {
-      if (selectOverlays.openModelSelector()) {
-        referenceActions.closeReferenceActions()
-      }
-    },
-    onOpenEffortSelector: () => {
-      if (selectOverlays.openEffortSelector()) {
-        referenceActions.closeReferenceActions()
-      }
-    },
-    onQueueTextareaFocusRestore: focusRestore.queueEditorFocusRestore,
-    onCloseReferenceActions: () => referenceActions.closeReferenceActions(),
-    onModelChange,
-    onToggleRecommendedModel,
-    onEffortChange,
-    onAdapterChange,
-    onAccountChange,
-    onQueueModeChange,
-    onSend,
-    onInterrupt,
-    onCancel,
-    onConfirmInteractionOption
-  } satisfies SenderToolbarHandlers
-}

package/src/components/chat/sender/@core/get-sender-interaction-state.ts

@@ -1,18 +0,0 @@
-import type { SenderProps } from '../@types/sender-props'
-
-import { shouldHideSenderForInteraction } from './interaction-request'
-
-export const getSenderInteractionState = ({
-  interactionRequest,
-  isInlineEdit
-}: {
-  interactionRequest: SenderProps['interactionRequest']
-  isInlineEdit: boolean
-}) => {
-  const hideSender = isInlineEdit ? false : shouldHideSenderForInteraction(interactionRequest)
-  const permissionContext = interactionRequest?.payload.kind === 'permission'
-    ? interactionRequest.payload.permissionContext
-    : undefined
-
-  return { hideSender, permissionContext }
-}

package/src/components/chat/sender/@core/get-sender-runtime-state.ts

@@ -1,15 +0,0 @@
-import type { SenderProps } from '../@types/sender-props'
-
-export const getSenderRuntimeState = (
-  props: Pick<SenderProps, 'forceEffortControl' | 'selectedAdapter' | 'sessionStatus' | 'submitLoading' | 'variant'>
-) => {
-  const isInlineEdit = props.variant === 'inline-edit'
-  const isMac = navigator.platform.includes('Mac')
-  const isThinking = !isInlineEdit && props.sessionStatus === 'running'
-  const isBusy = isThinking || props.submitLoading === true
-  const supportsEffort = props.forceEffortControl === true ||
-    props.selectedAdapter === 'codex' || props.selectedAdapter === 'claude-code' ||
-    props.selectedAdapter === 'copilot' || props.selectedAdapter === 'opencode'
-
-  return { isInlineEdit, isMac, isThinking, isBusy, supportsEffort }
-}

package/src/components/chat/sender/@core/interaction-request.ts

@@ -1,5 +0,0 @@
-import type { AskUserQuestionParams } from '@vibe-forge/core'
-
-export const shouldHideSenderForInteraction = (
-  _interactionRequest: { id: string; payload: AskUserQuestionParams } | null | undefined
-) => false

package/src/components/chat/sender/@core/sender-toolbar-bindings.ts

@@ -1,191 +0,0 @@
-import type { ReactNode } from 'react'
-
-import type { SessionQueuedMessageMode } from '@vibe-forge/core'
-
-import type { ChatEffort } from '#~/hooks/chat/use-chat-effort'
-import type { ModelSelectMenuGroup, ModelSelectOption } from '#~/hooks/chat/use-chat-model-adapter-selection'
-import type { PermissionMode } from '#~/hooks/chat/use-chat-permission-mode'
-
-import type {
-  SenderToolbarData,
-  SenderToolbarHandlers,
-  SenderToolbarRefs,
-  SenderToolbarState
-} from '../@types/sender-toolbar-types'
-
-import { createSenderToolbarHandlers } from './create-sender-toolbar-handlers'
-
-export const createSenderToolbarBindings = ({
-  attachments,
-  callbacks,
-  composer,
-  resources,
-  selection,
-  ui
-}: {
-  attachments: {
-    handleImageFileChange: SenderToolbarHandlers['onImageFileChange']
-    handleImageUpload: () => void
-    handleOpenContextPicker: () => void
-  }
-  callbacks: {
-    onAdapterChange?: (adapter: string) => void
-    onAccountChange?: (account: string) => void
-    onEffortChange?: (effort: ChatEffort) => void
-    onInterrupt: () => void
-    onModelChange?: (model: string) => void
-    onToggleRecommendedModel?: (option: ModelSelectOption) => void | Promise<void>
-    onPermissionModeChange?: (mode: PermissionMode) => void
-    onQueueModeChange?: (mode: SessionQueuedMessageMode) => void
-    onCancel?: () => void
-    onConfirmInteractionOption?: () => void
-    onSend: (mode?: SessionQueuedMessageMode) => void
-  }
-  composer: { input: string; pendingImageCount: number; pendingFileCount: number }
-  resources: { message: { warning: (content: ReactNode) => unknown }; t: (key: string) => string }
-  selection: {
-    adapterOptions?: Array<{ value: string; label: ReactNode }>
-    accountOptions?: SenderToolbarData['accountOptions']
-    effort: ChatEffort
-    effortOptions: SenderToolbarData['effortOptions']
-    modelMenuGroups?: ModelSelectMenuGroup[]
-    modelSearchOptions?: ModelSelectOption[]
-    permissionMode: PermissionMode
-    permissionModeOptions: SenderToolbarData['permissionModeOptions']
-    queueMode: SessionQueuedMessageMode
-    queuedMessageShortcuts: Pick<SenderToolbarData['composerControlShortcuts'], 'queueNext' | 'queueSteer'>
-    recommendedModelOptions?: ModelSelectOption[]
-    servicePreviewModelOptions?: ModelSelectOption[]
-    resolvedSendShortcut: string
-    selectedAdapter?: string
-    selectedAccount?: string
-    selectedModel?: string
-    updatingRecommendedModelValue?: string
-  }
-  ui: {
-    adapterLocked: boolean
-    canOpenReferenceActions: boolean
-    composerControlShortcuts: Pick<
-      SenderToolbarData['composerControlShortcuts'],
-      'switchEffort' | 'switchModel' | 'switchPermissionMode'
-    >
-    focusRestore: { queueEditorFocusRestore: () => void }
-    isInlineEdit: boolean
-    isMac: boolean
-    isThinking: boolean
-    sendBlocked: boolean
-    sendBlockedTooltip?: string
-    showConfirmInteractionAction: boolean
-    modelUnavailable?: boolean
-    hideReferenceActions: boolean
-    hideSubmitAction: boolean
-    referenceActions: {
-      showReferenceActions: boolean
-      showPermissionActions: boolean
-      setShowReferenceActions: (nextOpen: boolean) => void
-      setShowPermissionActions: (nextOpen: boolean) => void
-      closeReferenceActions: (options?: { restoreFocus?: boolean }) => void
-      handleReferenceMenuKeyDown: SenderToolbarHandlers['onReferenceMenuKeyDown']
-      handlePermissionMenuKeyDown: SenderToolbarHandlers['onPermissionMenuKeyDown']
-      referenceMenuNavigation: SenderToolbarRefs['referenceMenuNavigation']
-      permissionMenuNavigation: SenderToolbarRefs['permissionMenuNavigation']
-    }
-    refs: Pick<SenderToolbarRefs, 'effortSelectRef' | 'fileInputRef' | 'modelSelectRef'>
-    selectOverlays: {
-      showModelSelect: boolean
-      setShowModelSelect: (nextOpen: boolean) => void
-      showEffortSelect: boolean
-      setShowEffortSelect: (nextOpen: boolean) => void
-      modelSearchValue: string
-      setModelSearchValue: (value: string) => void
-      openModelSelector: () => boolean
-      openEffortSelector: () => boolean
-    }
-    showAccountSelector: boolean
-    submitLabel?: string
-    confirmInteractionLabel?: string
-    submitLoading: boolean
-    supportsEffort: boolean
-  }
-}) => {
-  const toolbarState: SenderToolbarState = {
-    isInlineEdit: ui.isInlineEdit,
-    isThinking: ui.isThinking,
-    modelUnavailable: Boolean(ui.modelUnavailable),
-    sendBlocked: ui.sendBlocked,
-    sendBlockedTooltip: ui.sendBlockedTooltip,
-    showConfirmInteractionAction: ui.showConfirmInteractionAction,
-    adapterLocked: ui.adapterLocked,
-    submitLoading: ui.submitLoading,
-    supportsEffort: ui.supportsEffort,
-    canOpenReferenceActions: ui.canOpenReferenceActions,
-    showModelSelect: ui.selectOverlays.showModelSelect,
-    showEffortSelect: ui.selectOverlays.showEffortSelect,
-    showReferenceActions: ui.referenceActions.showReferenceActions,
-    showPermissionActions: ui.referenceActions.showPermissionActions,
-    hideReferenceActions: ui.hideReferenceActions,
-    hideSubmitAction: ui.hideSubmitAction,
-    modelSearchValue: ui.selectOverlays.modelSearchValue,
-    selectedModel: selection.selectedModel,
-    effort: selection.effort,
-    permissionMode: selection.permissionMode,
-    selectedAdapter: selection.selectedAdapter,
-    selectedAccount: selection.selectedAccount,
-    showAccountSelector: ui.showAccountSelector,
-    isMac: ui.isMac,
-    resolvedSendShortcut: selection.resolvedSendShortcut,
-    queueMode: selection.queueMode,
-    showQueueModeControl: ui.isThinking && !ui.isInlineEdit,
-    hasComposerContent: composer.input.trim() !== '' || composer.pendingImageCount > 0 || composer.pendingFileCount > 0,
-    hasSendText: composer.input.trim() !== ''
-  }
-
-  const toolbarData: SenderToolbarData = {
-    modelMenuGroups: selection.modelMenuGroups,
-    modelSearchOptions: selection.modelSearchOptions,
-    recommendedModelOptions: selection.recommendedModelOptions,
-    servicePreviewModelOptions: selection.servicePreviewModelOptions,
-    updatingRecommendedModelValue: selection.updatingRecommendedModelValue,
-    effortOptions: selection.effortOptions,
-    permissionModeOptions: selection.permissionModeOptions,
-    adapterOptions: selection.adapterOptions,
-    accountOptions: selection.accountOptions,
-    composerControlShortcuts: {
-      ...ui.composerControlShortcuts,
-      ...selection.queuedMessageShortcuts
-    },
-    submitLabel: ui.submitLabel,
-    confirmInteractionLabel: ui.confirmInteractionLabel
-  }
-
-  const toolbarRefs: SenderToolbarRefs = {
-    ...ui.refs,
-    referenceMenuNavigation: ui.referenceActions.referenceMenuNavigation,
-    permissionMenuNavigation: ui.referenceActions.permissionMenuNavigation
-  }
-
-  const toolbarHandlers = createSenderToolbarHandlers({
-    attachments,
-    canOpenReferenceActions: ui.canOpenReferenceActions,
-    focusRestore: ui.focusRestore,
-    isInlineEdit: ui.isInlineEdit,
-    message: resources.message,
-    modelUnavailable: ui.modelUnavailable,
-    onAdapterChange: callbacks.onAdapterChange,
-    onAccountChange: callbacks.onAccountChange,
-    onEffortChange: callbacks.onEffortChange,
-    onInterrupt: callbacks.onInterrupt,
-    onModelChange: callbacks.onModelChange,
-    onToggleRecommendedModel: callbacks.onToggleRecommendedModel,
-    onPermissionModeChange: callbacks.onPermissionModeChange,
-    onQueueModeChange: callbacks.onQueueModeChange,
-    onCancel: callbacks.onCancel,
-    onConfirmInteractionOption: callbacks.onConfirmInteractionOption,
-    onSend: callbacks.onSend,
-    referenceActions: ui.referenceActions,
-    selectOverlays: ui.selectOverlays,
-    t: resources.t
-  })
-
-  return { toolbarState, toolbarData, toolbarRefs, toolbarHandlers }
-}

package/src/components/chat/sender/@hooks/use-model-select-browser.tsx

@@ -1,191 +0,0 @@
-import { Menu, Tooltip } from 'antd'
-import type { MenuProps } from 'antd'
-import { useCallback, useMemo } from 'react'
-import { useTranslation } from 'react-i18next'
-
-import type { ModelSelectMenuGroup, ModelSelectOption } from '#~/hooks/chat/use-chat-model-adapter-selection'
-import { useResponsiveLayout } from '#~/hooks/use-responsive-layout'
-
-import { ModelSelectOptionLabel } from '../@components/model-select/ModelSelectOptionLabel'
-
-export const useModelSelectBrowser = ({
-  hasModelSearchQuery,
-  modelMenuGroups,
-  onToggleRecommendedModel,
-  recommendedModelOptions,
-  servicePreviewModelOptions,
-  selectedModel,
-  updatingRecommendedModelValue,
-  onSelectModel
-}: {
-  hasModelSearchQuery: boolean
-  modelMenuGroups?: ModelSelectMenuGroup[]
-  onToggleRecommendedModel?: (option: ModelSelectOption) => void | Promise<void>
-  recommendedModelOptions?: ModelSelectOption[]
-  servicePreviewModelOptions?: ModelSelectOption[]
-  selectedModel?: string
-  updatingRecommendedModelValue?: string
-  onSelectModel: (value: string) => void
-}) => {
-  const { t } = useTranslation()
-  const { isTouchInteraction } = useResponsiveLayout()
-
-  const renderCompactModelMenuLabel = useCallback((option: ModelSelectOption) => {
-    return (
-      <ModelSelectOptionLabel
-        option={option}
-        showServicePrefix
-        onToggleRecommendedModel={onToggleRecommendedModel}
-        updatingRecommendedModelValue={updatingRecommendedModelValue}
-      />
-    )
-  }, [onToggleRecommendedModel, updatingRecommendedModelValue])
-
-  const renderModelMenuGroupLabel = useCallback((group: ModelSelectMenuGroup) => {
-    const label = (
-      <span className='model-menu-group-label'>
-        <span className='model-menu-group-title'>{group.title}</span>
-      </span>
-    )
-
-    if (!group.description) {
-      return label
-    }
-
-    return (
-      <Tooltip
-        title={group.description}
-        placement='left'
-        classNames={{ root: 'model-menu-tooltip' }}
-        mouseEnterDelay={.35}
-        destroyOnHidden
-      >
-        {label}
-      </Tooltip>
-    )
-  }, [])
-
-  const modelMenuItems = useMemo<MenuProps['items']>(() => {
-    const servicePreviewItems = (servicePreviewModelOptions ?? []).map(option => ({
-      key: `service-preview:${option.value}`,
-      label: renderCompactModelMenuLabel(option),
-      className: 'model-select-menu-item'
-    }))
-
-    const recommendedItems = (recommendedModelOptions ?? []).map(option => ({
-      key: `recommended:${option.value}`,
-      label: renderCompactModelMenuLabel(option),
-      className: 'model-select-menu-item'
-    }))
-
-    const moreModelChildren = (modelMenuGroups ?? [])
-      .filter(group => group.options.length > 0)
-      .map(group => ({
-        key: group.key,
-        label: renderModelMenuGroupLabel(group),
-        popupClassName: 'model-select-submenu-popup',
-        children: group.options.map(option => ({
-          key: option.value,
-          label: (
-            <ModelSelectOptionLabel
-              option={option}
-              onToggleRecommendedModel={onToggleRecommendedModel}
-              updatingRecommendedModelValue={updatingRecommendedModelValue}
-            />
-          ),
-          className: 'model-select-menu-item'
-        }))
-      }))
-
-    if (moreModelChildren.length === 0) {
-      if (recommendedItems.length === 0) {
-        return servicePreviewItems
-      }
-
-      return [
-        ...servicePreviewItems,
-        {
-          type: 'group',
-          key: 'recommended-group',
-          label: <span className='model-select-section-label'>{t('chat.modelGroupRecommended')}</span>,
-          children: recommendedItems
-        }
-      ]
-    }
-
-    return [
-      ...servicePreviewItems,
-      ...(recommendedItems.length > 0
-        ? [{
-          type: 'group' as const,
-          key: 'recommended-group',
-          label: <span className='model-select-section-label'>{t('chat.modelGroupRecommended')}</span>,
-          children: recommendedItems
-        }]
-        : []),
-      {
-        key: 'more-models',
-        label: <span className='model-more-menu-label'>{t('chat.modelMoreModels')}</span>,
-        popupClassName: 'model-select-submenu-popup',
-        children: moreModelChildren
-      }
-    ]
-  }, [
-    modelMenuGroups,
-    onToggleRecommendedModel,
-    recommendedModelOptions,
-    renderCompactModelMenuLabel,
-    renderModelMenuGroupLabel,
-    servicePreviewModelOptions,
-    t,
-    updatingRecommendedModelValue
-  ])
-
-  const handleModelMenuClick: MenuProps['onClick'] = ({ key, domEvent }) => {
-    domEvent.preventDefault()
-    if (typeof key !== 'string' || key === 'more-models') {
-      return
-    }
-    onSelectModel(key.replace(/^(service-preview:|recommended:)/, ''))
-  }
-
-  const selectedModelMenuKeys = useMemo(() => {
-    if (!selectedModel) return []
-
-    return [
-      selectedModel,
-      `service-preview:${selectedModel}`,
-      `recommended:${selectedModel}`
-    ]
-  }, [selectedModel])
-
-  const renderModelPopup = useCallback((menu: React.ReactElement) => {
-    if (hasModelSearchQuery || modelMenuItems == null || modelMenuItems.length === 0) {
-      return menu
-    }
-
-    return (
-      <div
-        className='model-select-browser'
-        onMouseDown={(event) => {
-          event.preventDefault()
-          event.stopPropagation()
-        }}
-      >
-        <Menu
-          className='model-select-menu'
-          mode='vertical'
-          selectable
-          selectedKeys={selectedModelMenuKeys}
-          triggerSubMenuAction={isTouchInteraction ? 'click' : 'hover'}
-          items={modelMenuItems}
-          onClick={handleModelMenuClick}
-        />
-      </div>
-    )
-  }, [hasModelSearchQuery, handleModelMenuClick, isTouchInteraction, modelMenuItems, selectedModelMenuKeys])
-
-  return {
-    renderModelPopup
-  }
-}