refactor & perf: `import { noop } from 'lodash-es'` across `web` (#17439)

web/app/components/app/annotation/batch-add-annotation-modal/index.tsx

 import { annotationBatchImport, checkAnnotationBatchImportProgress } from '@/service/annotation'
 import { useProviderContext } from '@/context/provider-context'
 import AnnotationFull from '@/app/components/billing/annotation-full'
+import { noop } from 'lodash-es'
 
 export enum ProcessStatus {
   WAITING = 'waiting',
   }
 
   return (
-    <Modal isShow={isShow} onClose={() => { }} className='!max-w-[520px] !rounded-xl px-8 py-6'>
+    <Modal isShow={isShow} onClose={noop} className='!max-w-[520px] !rounded-xl px-8 py-6'>
       <div className='system-xl-medium relative pb-1 text-text-primary'>{t('appAnnotation.batchModal.title')}</div>
       <div className='absolute right-4 top-4 cursor-pointer p-2' onClick={onCancel}>
         <RiCloseLine className='h-4 w-4 text-text-tertiary' />

web/app/components/app/configuration/base/operation-btn/index.tsx

   RiEditLine,
 } from '@remixicon/react'
 import cn from '@/utils/classnames'
+import { noop } from 'lodash-es'
 
 export type IOperationBtnProps = {
   className?: string
   className,
   type,
   actionName,
-  onClick = () => { },
+  onClick = noop,
 }) => {
   const { t } = useTranslation()
   return (

web/app/components/app/configuration/config-prompt/simple-prompt-input.tsx

 import { PROMPT_EDITOR_UPDATE_VALUE_BY_EVENT_EMITTER } from '@/app/components/base/prompt-editor/plugins/update-block'
 import useBreakpoints, { MediaType } from '@/hooks/use-breakpoints'
 import { useFeaturesStore } from '@/app/components/base/features/hooks'
+import { noop } from 'lodash-es'
 
 export type ISimplePromptInput = {
   mode: AppType
                 user: '',
                 assistant: '',
               },
-              onEditRole: () => { },
+              onEditRole: noop,
             }}
             queryBlock={{
               show: false,

web/app/components/app/configuration/config/agent/prompt-editor.tsx

 import ConfigContext from '@/context/debug-configuration'
 import { useModalContext } from '@/context/modal-context'
 import { useToastContext } from '@/app/components/base/toast'
-
 import s from '@/app/components/app/configuration/config-prompt/style.module.css'
+import { noop } from 'lodash-es'
+
 type Props = {
   className?: string
   type: 'first-prompt' | 'next-iteration'
                 user: '',
                 assistant: '',
               },
-              onEditRole: () => { },
+              onEditRole: noop,
             }}
             queryBlock={{
               show: false,
               selectable: false,
             }}
             onChange={onChange}
-            onBlur={() => { }}
+            onBlur={noop}
           />
         </div>
         <div className='flex pb-2 pl-4'>

web/app/components/app/configuration/dataset-config/params-config/weighted-score.tsx

 import './weighted-score.css'
 import Slider from '@/app/components/base/slider'
 import cn from '@/utils/classnames'
+import { noop } from 'lodash-es'
 
 const formatNumber = (value: number) => {
   if (value > 0 && value < 1)
 }
 const WeightedScore = ({
   value,
-  onChange = () => {},
+  onChange = noop,
 }: WeightedScoreProps) => {
   const { t } = useTranslation()
 

web/app/components/app/configuration/debug/debug-with-multiple-model/context.tsx

 
 import { createContext, useContext } from 'use-context-selector'
 import type { ModelAndParameter } from '../types'
+import { noop } from 'lodash-es'
 
 export type DebugWithMultipleModelContextType = {
   multipleModelConfigs: ModelAndParameter[]
 }
 const DebugWithMultipleModelContext = createContext<DebugWithMultipleModelContextType>({
   multipleModelConfigs: [],
-  onMultipleModelConfigsChange: () => {},
-  onDebugWithMultipleModelChange: () => {},
+  onMultipleModelConfigsChange: noop,
+  onDebugWithMultipleModelChange: noop,
 })
 
 export const useDebugWithMultipleModelContext = () => useContext(DebugWithMultipleModelContext)

web/app/components/app/configuration/debug/debug-with-multiple-model/text-generation-item.tsx

 import { useEventEmitterContextContext } from '@/context/event-emitter'
 import { useProviderContext } from '@/context/provider-context'
 import { useFeatures } from '@/app/components/base/features/hooks'
+import { noop } from 'lodash-es'
 
 type TextGenerationItemProps = {
   modelAndParameter: ModelAndParameter
       siteInfo={null}
       messageId={messageId}
       isError={false}
-      onRetry={() => { }}
+      onRetry={noop}
       inSidePanel
     />
   )

web/app/components/app/configuration/debug/index.tsx

 import PromptLogModal from '@/app/components/base/prompt-log-modal'
 import { useStore as useAppStore } from '@/app/components/app/store'
 import { useFeatures, useFeaturesStore } from '@/app/components/base/features/hooks'
+import { noop } from 'lodash-es'
 
 type IDebug = {
   isAPIKeySet: boolean
                         isInstalledApp={false}
                         messageId={messageId}
                         isError={false}
-                        onRetry={() => { }}
+                        onRetry={noop}
                         siteInfo={null}
                       />
                     </div>

web/app/components/app/configuration/tools/external-data-tool-modal.tsx

 } from '@/models/common'
 import { useToastContext } from '@/app/components/base/toast'
 import AppIcon from '@/app/components/base/app-icon'
+import { noop } from 'lodash-es'
 
 const systemTypes = ['api']
 type ExternalDataToolModalProps = {
   return (
     <Modal
       isShow
-      onClose={() => { }}
+      onClose={noop}
       className='!w-[640px] !max-w-none !p-8 !pb-6'
     >
       <div className='mb-2 text-xl font-semibold text-gray-900'>

web/app/components/app/create-from-dsl-modal/index.tsx

 import { getRedirection } from '@/utils/app-redirection'
 import cn from '@/utils/classnames'
 import { usePluginDependencies } from '@/app/components/workflow/plugin-dependency/hooks'
+import { noop } from 'lodash-es'
 
 type CreateFromDSLModalProps = {
   show: boolean
       <Modal
         className='w-[520px] rounded-2xl border-[0.5px] border-components-panel-border bg-components-panel-bg p-0 shadow-xl'
         isShow={show}
-        onClose={() => { }}
+        onClose={noop}
       >
         <div className='title-2xl-semi-bold flex items-center justify-between pb-3 pl-6 pr-5 pt-6 text-text-primary'>
           {t('app.importFromDSL')}

web/app/components/app/duplicate-modal/index.tsx

 import { useProviderContext } from '@/context/provider-context'
 import AppsFull from '@/app/components/billing/apps-full-in-dialog'
 import type { AppIconType } from '@/types/app'
+import { noop } from 'lodash-es'
 
 export type DuplicateAppModalProps = {
   appName: string
     <>
       <Modal
         isShow={show}
-        onClose={() => { }}
+        onClose={noop}
         className={cn('relative !max-w-[480px]', 'px-8')}
       >
         <div className='absolute right-4 top-4 cursor-pointer p-2' onClick={onHide}>

web/app/components/app/log/list.tsx

 import { buildChatItemTree, getThreadMessages } from '@/app/components/base/chat/utils'
 import { getProcessedFilesFromResponse } from '@/app/components/base/file-uploader/utils'
 import cn from '@/utils/classnames'
+import { noop } from 'lodash-es'
 
 dayjs.extend(utc)
 dayjs.extend(timezone)
               content={detail.message.answer}
               messageId={detail.message.id}
               isError={false}
-              onRetry={() => { }}
+              onRetry={noop}
               isInstalledApp={false}
               supportFeedback
               feedback={detail.message.feedbacks.find((item: any) => item.from_source === 'admin')}

web/app/components/app/switch-app-modal/index.tsx

 import { AlertTriangle } from '@/app/components/base/icons/src/vender/solid/alertsAndFeedback'
 import AppIcon from '@/app/components/base/app-icon'
 import { useStore as useAppStore } from '@/app/components/app/store'
+import { noop } from 'lodash-es'
 
 type SwitchAppModalProps = {
   show: boolean
       <Modal
         className={cn('w-[600px] max-w-[600px] p-8')}
         isShow={show}
-        onClose={() => { }}
+        onClose={noop}
       >
         <div className='absolute right-4 top-4 cursor-pointer p-2' onClick={onClose}>
           <RiCloseLine className='h-4 w-4 text-text-tertiary' />

web/app/components/base/app-icon-picker/index.tsx

 import type { AppIconType, ImageFile } from '@/types/app'
 import cn from '@/utils/classnames'
 import { DISABLE_UPLOAD_IMAGE_AS_ICON } from '@/config'
+import { noop } from 'lodash-es'
 
 export type AppIconEmojiSelection = {
   type: 'emoji'
   }
 
   return <Modal
-    onClose={() => { }}
+    onClose={noop}
     isShow
     closable={false}
     wrapperClassName={className}

web/app/components/base/chat/chat-with-history/context.tsx

   AppMeta,
   ConversationItem,
 } from '@/models/share'
+import { noop } from 'lodash-es'
 
 export type ChatWithHistoryContextValue = {
   appInfoError?: any
   conversationList: [],
   newConversationInputs: {},
   newConversationInputsRef: { current: {} },
-  handleNewConversationInputsChange: () => {},
+  handleNewConversationInputsChange: noop,
   inputsForms: [],
-  handleNewConversation: () => {},
-  handleStartChat: () => {},
-  handleChangeConversation: () => {},
-  handlePinConversation: () => {},
-  handleUnpinConversation: () => {},
-  handleDeleteConversation: () => {},
+  handleNewConversation: noop,
+  handleStartChat: noop,
+  handleChangeConversation: noop,
+  handlePinConversation: noop,
+  handleUnpinConversation: noop,
+  handleDeleteConversation: noop,
   conversationRenaming: false,
-  handleRenameConversation: () => {},
-  handleNewConversationCompleted: () => {},
+  handleRenameConversation: noop,
+  handleNewConversationCompleted: noop,
   chatShouldReloadKey: '',
   isMobile: false,
   isInstalledApp: false,
-  handleFeedback: () => {},
-  currentChatInstanceRef: { current: { handleStop: () => {} } },
+  handleFeedback: noop,
+  currentChatInstanceRef: { current: { handleStop: noop } },
   sidebarCollapseState: false,
-  handleSidebarCollapse: () => {},
+  handleSidebarCollapse: noop,
   clearChatList: false,
-  setClearChatList: () => {},
+  setClearChatList: noop,
   isResponding: false,
-  setIsResponding: () => {},
+  setIsResponding: noop,
   currentConversationInputs: {},
-  setCurrentConversationInputs: () => {},
+  setCurrentConversationInputs: noop,
 })
 export const useChatWithHistoryContext = () => useContext(ChatWithHistoryContext)

web/app/components/base/chat/chat-with-history/hooks.tsx

 import { useAppFavicon } from '@/hooks/use-app-favicon'
 import { InputVarType } from '@/app/components/workflow/types'
 import { TransferMethod } from '@/types/app'
+import { noop } from 'lodash-es'
 
 function getFormattedChatList(messages: any[]) {
   const newChatList: ChatItem[] = []
       callback?.()
     }
   }, [setShowNewConversationItemInList, checkInputsRequired])
-  const currentChatInstanceRef = useRef<{ handleStop: () => void }>({ handleStop: () => { } })
+  const currentChatInstanceRef = useRef<{ handleStop: () => void }>({ handleStop: noop })
   const handleChangeConversation = useCallback((conversationId: string) => {
     currentChatInstanceRef.current.handleStop()
     setNewConversationId('')

web/app/components/base/chat/embedded-chatbot/context.tsx

   AppMeta,
   ConversationItem,
 } from '@/models/share'
+import { noop } from 'lodash-es'
 
 export type EmbeddedChatbotContextValue = {
   appInfoError?: any
   conversationList: [],
   newConversationInputs: {},
   newConversationInputsRef: { current: {} },
-  handleNewConversationInputsChange: () => {},
+  handleNewConversationInputsChange: noop,
   inputsForms: [],
-  handleNewConversation: () => {},
-  handleStartChat: () => {},
-  handleChangeConversation: () => {},
-  handleNewConversationCompleted: () => {},
+  handleNewConversation: noop,
+  handleStartChat: noop,
+  handleChangeConversation: noop,
+  handleNewConversationCompleted: noop,
   chatShouldReloadKey: '',
   isMobile: false,
   isInstalledApp: false,
-  handleFeedback: () => {},
-  currentChatInstanceRef: { current: { handleStop: () => {} } },
+  handleFeedback: noop,
+  currentChatInstanceRef: { current: { handleStop: noop } },
   clearChatList: false,
-  setClearChatList: () => {},
+  setClearChatList: noop,
   isResponding: false,
-  setIsResponding: () => {},
+  setIsResponding: noop,
   currentConversationInputs: {},
-  setCurrentConversationInputs: () => {},
+  setCurrentConversationInputs: noop,
 })
 export const useEmbeddedChatbotContext = () => useContext(EmbeddedChatbotContext)

web/app/components/base/chat/embedded-chatbot/hooks.tsx

 import { InputVarType } from '@/app/components/workflow/types'
 import { TransferMethod } from '@/types/app'
 import { addFileInfos, sortAgentSorts } from '@/app/components/tools/utils'
+import { noop } from 'lodash-es'
 
 function getFormattedChatList(messages: any[]) {
   const newChatList: ChatItem[] = []
       callback?.()
     }
   }, [setShowNewConversationItemInList, checkInputsRequired])
-  const currentChatInstanceRef = useRef<{ handleStop: () => void }>({ handleStop: () => { } })
+  const currentChatInstanceRef = useRef<{ handleStop: () => void }>({ handleStop: noop })
   const handleChangeConversation = useCallback((conversationId: string) => {
     currentChatInstanceRef.current.handleStop()
     setNewConversationId('')

web/app/components/base/emoji-picker/index.tsx

 import Divider from '@/app/components/base/divider'
 import Button from '@/app/components/base/button'
 import Modal from '@/app/components/base/modal'
+import { noop } from 'lodash-es'
 
 type IEmojiPickerProps = {
   isModal?: boolean
 
   return isModal
     ? <Modal
-      onClose={() => { }}
+      onClose={noop}
       isShow
       closable={false}
       wrapperClassName={className}

web/app/components/base/features/new-feature-panel/conversation-opener/modal.tsx

 import type { InputVar } from '@/app/components/workflow/types'
 import { getNewVar } from '@/utils/var'
 import cn from '@/utils/classnames'
+import { noop } from 'lodash-es'
 
 type OpeningSettingModalProps = {
   data: OpeningStatement
   return (
     <Modal
       isShow
-      onClose={() => { }}
+      onClose={noop}
       className='!mt-14 !w-[640px] !max-w-none !bg-components-panel-bg-blur !p-6'
     >
       <div className='mb-6 flex items-center justify-between'>

web/app/components/base/features/new-feature-panel/moderation/moderation-setting-modal.tsx

 import { useModalContext } from '@/context/modal-context'
 import { CustomConfigurationStatusEnum } from '@/app/components/header/account-setting/model-provider-page/declarations'
 import cn from '@/utils/classnames'
+import { noop } from 'lodash-es'
 
 const systemTypes = ['openai_moderation', 'keywords', 'api']
 
   return (
     <Modal
       isShow
-      onClose={() => { }}
+      onClose={noop}
       className='!mt-14 !w-[600px] !max-w-none !p-6'
     >
       <div className='flex items-center justify-between'>

web/app/components/base/file-uploader/hooks.ts

 import { formatFileSize } from '@/utils/format'
 import { uploadRemoteFileInfo } from '@/service/common'
 import type { FileUploadConfigResponse } from '@/models/common'
+import { noop } from 'lodash-es'
 
 export const useFileSizeLimit = (fileUploadConfig?: FileUploadConfigResponse) => {
   const imgSizeLimit = Number(fileUploadConfig?.image_file_size_limit) * 1024 * 1024 || IMG_SIZE_LIMIT
     })
   }, [checkSizeLimit, handleAddFile, handleUpdateFile, notify, t, handleRemoveFile, fileConfig?.allowed_file_types, fileConfig.allowed_file_extensions, startProgressTimer, params.token])
 
-  const handleLoadFileFromLinkSuccess = useCallback(() => { }, [])
+  const handleLoadFileFromLinkSuccess = useCallback(noop, [])
 
-  const handleLoadFileFromLinkError = useCallback(() => { }, [])
+  const handleLoadFileFromLinkError = useCallback(noop, [])
 
   const handleClearFiles = useCallback(() => {
     const {

web/app/components/base/file-uploader/pdf-preview.tsx

 import Loading from '@/app/components/base/loading'
 import useBreakpoints, { MediaType } from '@/hooks/use-breakpoints'
 import Tooltip from '@/app/components/base/tooltip'
+import { noop } from 'lodash-es'
 
 type PdfPreviewProps = {
   url: string
               <PdfHighlighter
                 pdfDocument={pdfDocument}
                 enableAreaSelection={event => event.altKey}
-                scrollRef={() => { }}
-                onScrollChange={() => { }}
+                scrollRef={noop}
+                onScrollChange={noop}
                 onSelectionFinished={() => null}
                 highlightTransform={() => { return <div/> }}
                 highlights={[]}

web/app/components/base/fullscreen-modal/index.tsx

 import { Dialog, DialogPanel, Transition, TransitionChild } from '@headlessui/react'
 import { RiCloseLargeLine } from '@remixicon/react'
 import classNames from '@/utils/classnames'
+import { noop } from 'lodash-es'
 
 type IModal = {
   className?: string
   className,
   wrapperClassName,
   open,
-  onClose = () => { },
+  onClose = noop,
   children,
   closable = false,
   overflowVisible = false,

web/app/components/base/image-uploader/image-preview.tsx

 import { useHotkeys } from 'react-hotkeys-hook'
 import Tooltip from '@/app/components/base/tooltip'
 import Toast from '@/app/components/base/toast'
+import { noop } from 'lodash-es'
 
 type ImagePreviewProps = {
   url: string
   useHotkeys('esc', onCancel)
   useHotkeys('up', zoomIn)
   useHotkeys('down', zoomOut)
-  useHotkeys('left', onPrev || (() => { }))
-  useHotkeys('right', onNext || (() => { }))
+  useHotkeys('left', onPrev || noop)
+  useHotkeys('right', onNext || noop)
 
   return createPortal(
     <div className='image-preview-container fixed inset-0 z-[1000] flex items-center justify-center bg-black/80 p-8'

web/app/components/base/input/index.tsx

 import { RiCloseCircleFill, RiErrorWarningLine, RiSearchLine } from '@remixicon/react'
 import { type VariantProps, cva } from 'class-variance-authority'
 import cn from '@/utils/classnames'
+import { noop } from 'lodash-es'
 
 export const inputVariants = cva(
   '',
   styleCss,
   value,
   placeholder,
-  onChange = () => { },
+  onChange = noop,
   unit,
   ...props
 }: InputProps) => {

web/app/components/base/modal/index.tsx

 import { Fragment } from 'react'
 import { RiCloseLine } from '@remixicon/react'
 import classNames from '@/utils/classnames'
+import { noop } from 'lodash-es'
 // https://headlessui.com/react/dialog
 
 type IModal = {
   className,
   wrapperClassName,
   isShow,
-  onClose = () => { },
+  onClose = noop,
   title,
   description,
   children,

web/app/components/base/notion-page-selector/notion-page-selector-modal/index.tsx

 import type { NotionPage } from '@/models/common'
 import cn from '@/utils/classnames'
 import Modal from '@/app/components/base/modal'
+import { noop } from 'lodash-es'
 
 type NotionPageSelectorModalProps = {
   isShow: boolean
     <Modal
       className={s.modal}
       isShow={isShow}
-      onClose={() => { }}
+      onClose={noop}
     >
       <div className='mb-6 flex h-8 items-center justify-between'>
         <div className='text-xl font-semibold text-gray-900'>{t('common.dataSource.notion.selector.addPages')}</div>

web/app/components/base/prompt-editor/plugins/context-block/context-block-replacement-block.tsx

   ContextBlockNode,
 } from '../context-block/node'
 import { CustomTextNode } from '../custom-text/node'
+import { noop } from 'lodash-es'
 
 const REGEX = new RegExp(CONTEXT_PLACEHOLDER_TEXT)
 
 const ContextBlockReplacementBlock = ({
   datasets = [],
-  onAddContext = () => {},
+  onAddContext = noop,
   onInsert,
   canNotAddContext,
 }: ContextBlockType) => {

web/app/components/base/prompt-editor/plugins/context-block/index.tsx

   $createContextBlockNode,
   ContextBlockNode,
 } from './node'
+import { noop } from 'lodash-es'
 
 export const INSERT_CONTEXT_BLOCK_COMMAND = createCommand('INSERT_CONTEXT_BLOCK_COMMAND')
 export const DELETE_CONTEXT_BLOCK_COMMAND = createCommand('DELETE_CONTEXT_BLOCK_COMMAND')
 
 const ContextBlock = memo(({
   datasets = [],
-  onAddContext = () => {},
+  onAddContext = noop,
   onInsert,
   onDelete,
   canNotAddContext,

web/app/components/base/prompt-editor/plugins/history-block/history-block-replacement-block.tsx

   HistoryBlockNode,
 } from '../history-block/node'
 import { CustomTextNode } from '../custom-text/node'
+import { noop } from 'lodash-es'
 
 const REGEX = new RegExp(HISTORY_PLACEHOLDER_TEXT)
 
 const HistoryBlockReplacementBlock = ({
   history = { user: '', assistant: '' },
-  onEditRole = () => {},
+  onEditRole = noop,
   onInsert,
 }: HistoryBlockType) => {
   const [editor] = useLexicalComposerContext()

web/app/components/base/prompt-editor/plugins/history-block/index.tsx

   $createHistoryBlockNode,
   HistoryBlockNode,
 } from './node'
+import { noop } from 'lodash-es'
 
 export const INSERT_HISTORY_BLOCK_COMMAND = createCommand('INSERT_HISTORY_BLOCK_COMMAND')
 export const DELETE_HISTORY_BLOCK_COMMAND = createCommand('DELETE_HISTORY_BLOCK_COMMAND')
 
 const HistoryBlock = memo(({
   history = { user: '', assistant: '' },
-  onEditRole = () => {},
+  onEditRole = noop,
   onInsert,
   onDelete,
 }: HistoryBlockType) => {

web/app/components/base/radio-card/index.tsx

 import type { FC } from 'react'
 import React from 'react'
 import cn from '@/utils/classnames'
+import { noop } from 'lodash-es'
 
 type Props = {
   className?: string
   description,
   noRadio,
   isChosen,
-  onChosen = () => { },
+  onChosen = noop,
   chosenConfig,
   chosenConfigWrapClassName,
   className,

web/app/components/base/tag-management/selector.tsx

 import Checkbox from '@/app/components/base/checkbox'
 import { bindTag, createTag, fetchTagList, unBindTag } from '@/service/tag'
 import { ToastContext } from '@/app/components/base/toast'
+import { noop } from 'lodash-es'
 
 type TagSelectorProps = {
   targetID: string
               <Checkbox
                 className='shrink-0'
                 checked={selectedTagIDs.includes(tag.id)}
-                onCheck={() => { }}
+                onCheck={noop}
               />
               <div title={tag.name} className='grow truncate text-sm leading-5 text-text-secondary'>{tag.name}</div>
             </div>
               <Checkbox
                 className='shrink-0'
                 checked={selectedTagIDs.includes(tag.id)}
-                onCheck={() => { }}
+                onCheck={noop}
               />
               <div title={tag.name} className='grow truncate text-sm leading-5 text-text-secondary'>{tag.name}</div>
             </div>

web/app/components/base/tag-management/tag-remove-modal.tsx

 import Modal from '@/app/components/base/modal'
 import { AlertTriangle } from '@/app/components/base/icons/src/vender/solid/alertsAndFeedback'
 import type { Tag } from '@/app/components/base/tag-management/constant'
+import { noop } from 'lodash-es'
 
 type TagRemoveModalProps = {
   show: boolean
     <Modal
       className={cn('w-[480px] max-w-[480px] p-8')}
       isShow={show}
-      onClose={() => { }}
+      onClose={noop}
     >
       <div className='absolute right-4 top-4 cursor-pointer p-2' onClick={onClose}>
         <RiCloseLine className='h-4 w-4 text-text-tertiary' />

web/app/components/base/toast/index.spec.tsx

 import { act, render, screen, waitFor } from '@testing-library/react'
 import Toast, { ToastProvider, useToastContext } from '.'
 import '@testing-library/jest-dom'
+import { noop } from 'lodash-es'
 
 // Mock timers for testing timeouts
 jest.useFakeTimers()
 
     test('does not render close button when close is undefined', () => {
       // Create a modified context where close is undefined
-      const CustomToastContext = React.createContext({ notify: () => { }, close: undefined })
+      const CustomToastContext = React.createContext({ notify: noop, close: undefined })
 
       // Create a wrapper component using the custom context
       const Wrapper = ({ children }: any) => (
-        <CustomToastContext.Provider value={{ notify: () => { }, close: undefined }}>
+        <CustomToastContext.Provider value={{ notify: noop, close: undefined }}>
           {children}
         </CustomToastContext.Provider>
       )

web/app/components/base/toast/index.tsx

 import { createContext, useContext } from 'use-context-selector'
 import ActionButton from '@/app/components/base/action-button'
 import classNames from '@/utils/classnames'
+import { noop } from 'lodash-es'
 
 export type IToastProps = {
   type?: 'success' | 'error' | 'warning' | 'info'
 
     root.render(
       <ToastContext.Provider value={{
-        notify: () => { },
+        notify: noop,
         close: () => {
           if (holder) {
             root.unmount()

web/app/components/base/with-input-validation/index.spec.tsx

 import '@testing-library/jest-dom'
 import { z } from 'zod'
 import withValidation from '.'
+import { noop } from 'lodash-es'
 
 describe('withValidation HOC', () => {
   // schema for validation
   const WrappedComponent = withValidation(TestComponent, schema)
 
   beforeAll(() => {
-    jest.spyOn(console, 'error').mockImplementation(() => { })
+    jest.spyOn(console, 'error').mockImplementation(noop)
   })
 
   afterAll(() => {

web/app/components/datasets/common/document-status-with-action/index-failed.tsx

 import StatusWithAction from './status-with-action'
 import { getErrorDocs, retryErrorDocs } from '@/service/datasets'
 import type { IndexingStatusResponse } from '@/models/datasets'
+import { noop } from 'lodash-es'
 
 type Props = {
   datasetId: string
       description={`${errorDocs?.total} ${t('dataset.docsFailedNotice')}`}
       actionText={t('dataset.retry')}
       disabled={indexState.value === 'retry'}
-      onAction={indexState.value === 'error' ? onRetryErrorDocs : () => { }}
+      onAction={indexState.value === 'error' ? onRetryErrorDocs : noop}
     />
   )
 }

web/app/components/datasets/documents/detail/batch-modal/index.tsx

 import Button from '@/app/components/base/button'
 import Modal from '@/app/components/base/modal'
 import type { ChunkingMode } from '@/models/datasets'
+import { noop } from 'lodash-es'
 
 export type IBatchModalProps = {
   isShow: boolean
   }, [isShow])
 
   return (
-    <Modal isShow={isShow} onClose={() => { }} className='!max-w-[520px] !rounded-xl px-8 py-6'>
+    <Modal isShow={isShow} onClose={noop} className='!max-w-[520px] !rounded-xl px-8 py-6'>
       <div className='relative pb-1 text-xl font-medium leading-[30px] text-gray-900'>{t('datasetDocuments.list.batchModal.title')}</div>
       <div className='absolute right-4 top-4 cursor-pointer p-2' onClick={onCancel}>
         <RiCloseLine className='h-4 w-4 text-gray-500' />

web/app/components/datasets/documents/detail/completed/common/full-screen-drawer.tsx

 import React, { type FC } from 'react'
 import Drawer from '@/app/components/base/drawer'
 import classNames from '@/utils/classnames'
+import { noop } from 'lodash-es'
 
 type IFullScreenDrawerProps = {
   isOpen: boolean
 
 const FullScreenDrawer: FC<IFullScreenDrawerProps> = ({
   isOpen,
-  onClose = () => {},
+  onClose = noop,
   fullScreen,
   children,
 }) => {

web/app/components/datasets/documents/detail/completed/common/regeneration-modal.tsx

 import Modal from '@/app/components/base/modal'
 import Button from '@/app/components/base/button'
 import { useEventEmitterContextContext } from '@/context/event-emitter'
+import { noop } from 'lodash-es'
 
 type IDefaultContentProps = {
   onCancel: () => void
   })
 
   return (
-    <Modal isShow={isShow} onClose={() => {}} className='!max-w-[480px] !rounded-2xl'>
+    <Modal isShow={isShow} onClose={noop} className='!max-w-[480px] !rounded-2xl'>
       {!loading && !updateSucceeded && <DefaultContent onCancel={onCancel} onConfirm={onConfirm} />}
       {loading && !updateSucceeded && <RegeneratingContent />}
       {!loading && updateSucceeded && <RegenerationCompletedContent onClose={onClose} />}

web/app/components/datasets/documents/detail/completed/index.tsx

   useUpdateSegment,
 } from '@/service/knowledge/use-segment'
 import { useInvalid } from '@/service/use-base'
+import { noop } from 'lodash-es'
 
 const DEFAULT_LIMIT = 10
 
 const SegmentListContext = createContext<SegmentListContextValue>({
   isCollapsed: true,
   fullScreen: false,
-  toggleFullScreen: () => {},
+  toggleFullScreen: noop,
   currSegment: { showModal: false },
   currChildChunk: { showModal: false },
 })

web/app/components/datasets/metadata/metadata-dataset/create-content.tsx

 import Input from '@/app/components/base/input'
 import { RiArrowLeftLine } from '@remixicon/react'
 import { useTranslation } from 'react-i18next'
+import { noop } from 'lodash-es'
 
 const i18nPrefix = 'dataset.metadata.createMetadata'
 
 }
 
 const CreateContent: FC<Props> = ({
-  onClose = () => { },
+  onClose = noop,
   hasBack,
   onBack,
   onSave,

web/app/components/datasets/rename-modal/index.tsx

 import { ToastContext } from '@/app/components/base/toast'
 import type { DataSet } from '@/models/datasets'
 import { updateDatasetSetting } from '@/service/datasets'
+import { noop } from 'lodash-es'
 
 type RenameDatasetModalProps = {
   show: boolean
     <Modal
       className='w-[520px] max-w-[520px] rounded-xl px-8 py-6'
       isShow={show}
-      onClose={() => { }}
+      onClose={noop}
     >
       <div className='relative pb-2 text-xl font-medium leading-[30px] text-text-primary'>{t('datasetSettings.title')}</div>
       <div className='absolute right-4 top-4 cursor-pointer p-2' onClick={onClose}>

web/app/components/header/account-about/index.tsx

 import type { LangGeniusVersionResponse } from '@/models/common'
 import { IS_CE_EDITION } from '@/config'
 import LogoSite from '@/app/components/base/logo/logo-site'
+import { noop } from 'lodash-es'
 
 type IAccountSettingProps = {
   langeniusVersionInfo: LangGeniusVersionResponse
   return (
     <Modal
       isShow
-      onClose={() => { }}
+      onClose={noop}
       className='!w-[480px] !max-w-[480px] !px-6 !py-4'
     >
       <div className='relative pt-4'>

web/app/components/header/account-setting/api-based-extension-page/modal.tsx

   updateApiBasedExtension,
 } from '@/service/common'
 import { useToastContext } from '@/app/components/base/toast'
+import { noop } from 'lodash-es'
 
 export type ApiBasedExtensionData = {
   name?: string
   return (
     <Modal
       isShow
-      onClose={() => { }}
+      onClose={noop}
       className='!w-[640px] !max-w-none !p-8 !pb-6'
     >
       <div className='mb-2 text-xl font-semibold text-text-primary'>

web/app/components/header/account-setting/data-source-page/data-source-notion/index.tsx

 import { useAppContext } from '@/context/app-context'
 import { fetchNotionConnection } from '@/service/common'
 import NotionIcon from '@/app/components/base/notion-icon'
+import { noop } from 'lodash-es'
 
 const Icon: FC<{
   src: string
           total: workspace.source_info.total || 0,
         },
       }))}
-      onRemove={() => { }} // handled in operation/index.tsx
+      onRemove={noop} // handled in operation/index.tsx
       notionActions={{
         onChangeAuthorizedPage: handleAuthAgain,
       }}

web/app/components/header/account-setting/members-page/edit-workspace-modal/index.tsx

 import { useAppContext } from '@/context/app-context'
 import { updateWorkspaceInfo } from '@/service/common'
 import { ToastContext } from '@/app/components/base/toast'
+import { noop } from 'lodash-es'
+
 type IEditWorkspaceModalProps = {
   onCancel: () => void
 }
 
   return (
     <div className={cn(s.wrap)}>
-      <Modal overflowVisible isShow onClose={() => {}} className={cn(s.modal)}>
+      <Modal overflowVisible isShow onClose={noop} className={cn(s.modal)}>
         <div className='mb-2 flex justify-between'>
           <div className='text-xl font-semibold text-text-primary'>{t('common.account.editWorkspaceInfo')}</div>
           <RiCloseLine className='h-4 w-4 cursor-pointer text-text-tertiary' onClick={onCancel} />

web/app/components/header/account-setting/members-page/invite-modal/index.tsx

 import { ToastContext } from '@/app/components/base/toast'
 import type { InvitationResult } from '@/models/common'
 import I18n from '@/context/i18n'
-
 import 'react-multi-email/dist/style.css'
+import { noop } from 'lodash-es'
+
 type IInviteModalProps = {
   isEmailSetup: boolean
   onCancel: () => void
 
   return (
     <div className={cn(s.wrap)}>
-      <Modal overflowVisible isShow onClose={() => { }} className={cn(s.modal)}>
+      <Modal overflowVisible isShow onClose={noop} className={cn(s.modal)}>
         <div className='mb-2 flex justify-between'>
           <div className='text-xl font-semibold text-text-primary'>{t('common.members.inviteTeamMember')}</div>
           <RiCloseLine className='h-4 w-4 cursor-pointer text-text-tertiary' onClick={onCancel} />

web/app/components/header/account-setting/members-page/invited-modal/index.tsx

 import { IS_CE_EDITION } from '@/config'
 import type { InvitationResult } from '@/models/common'
 import Tooltip from '@/app/components/base/tooltip'
+import { noop } from 'lodash-es'
 
 export type SuccessInvitationResult = Extract<InvitationResult, { status: 'success' }>
 export type FailedInvitationResult = Extract<InvitationResult, { status: 'failed' }>
 
   return (
     <div className={s.wrap}>
-      <Modal isShow onClose={() => {}} className={s.modal}>
+      <Modal isShow onClose={noop} className={s.modal}>
         <div className='mb-3 flex justify-between'>
           <div className='
             flex h-12 w-12 items-center justify-center rounded-xl

web/app/components/header/account-setting/menu-dialog.tsx

 import type { ReactNode } from 'react'
 import { Dialog, DialogPanel, Transition, TransitionChild } from '@headlessui/react'
 import cn from '@/utils/classnames'
+import { noop } from 'lodash-es'
 
 type DialogProps = {
   className?: string
 
   return (
     <Transition appear show={show} as={Fragment}>
-      <Dialog as="div" className="relative z-[60]" onClose={() => { }}>
+      <Dialog as="div" className="relative z-[60]" onClose={noop}>
         <div className="fixed inset-0">
           <div className="flex min-h-full flex-col items-center justify-center">
             <TransitionChild>

web/app/components/header/app-selector/index.tsx

 import CreateAppDialog from '@/app/components/app/create-app-dialog'
 import AppIcon from '@/app/components/base/app-icon'
 import { useAppContext } from '@/context/app-context'
+import { noop } from 'lodash-es'
 
 type IAppSelectorProps = {
   appItems: AppDetailResponse[]
       <CreateAppDialog
         show={showNewAppDialog}
         onClose={() => setShowNewAppDialog(false)}
-        onSuccess={() => { }}
+        onSuccess={noop}
       />
     </div>
   )

web/app/components/plugins/marketplace/context.tsx

   getMarketplaceListFilterType,
 } from './utils'
 import { useInstalledPluginList } from '@/service/use-plugins'
+import { noop } from 'lodash-es'
 
 export type MarketplaceContextValue = {
   intersected: boolean
 
 export const MarketplaceContext = createContext<MarketplaceContextValue>({
   intersected: true,
-  setIntersected: () => {},
+  setIntersected: noop,
   searchPluginText: '',
-  handleSearchPluginTextChange: () => {},
+  handleSearchPluginTextChange: noop,
   filterPluginTags: [],
-  handleFilterPluginTagsChange: () => {},
+  handleFilterPluginTagsChange: noop,
   activePluginType: 'all',
-  handleActivePluginTypeChange: () => {},
+  handleActivePluginTypeChange: noop,
   page: 1,
-  handlePageChange: () => {},
+  handlePageChange: noop,
   plugins: undefined,
   pluginsTotal: 0,
-  resetPlugins: () => {},
+  resetPlugins: noop,
   sort: DEFAULT_SORT,
-  handleSortChange: () => {},
-  handleQueryPlugins: () => {},
-  handleMoreClick: () => {},
+  handleSortChange: noop,
+  handleQueryPlugins: noop,
+  handleMoreClick: noop,
   marketplaceCollectionsFromClient: [],
-  setMarketplaceCollectionsFromClient: () => {},
+  setMarketplaceCollectionsFromClient: noop,
   marketplaceCollectionPluginsMapFromClient: {},
-  setMarketplaceCollectionPluginsMapFromClient: () => {},
+  setMarketplaceCollectionPluginsMapFromClient: noop,
   isLoading: false,
   isSuccessCollections: false,
 })

web/app/components/plugins/plugin-page/context.tsx

 import type { FilterState } from './filter-management'
 import { useTranslation } from 'react-i18next'
 import { useTabSearchParams } from '@/hooks/use-tab-searchparams'
+import { noop } from 'lodash-es'
 
 export type PluginPageContextValue = {
   containerRef: React.RefObject<HTMLDivElement>
 export const PluginPageContext = createContext<PluginPageContextValue>({
   containerRef: { current: null },
   currentPluginID: undefined,
-  setCurrentPluginID: () => { },
+  setCurrentPluginID: noop,
   filters: {
     categories: [],
     tags: [],
     searchQuery: '',
   },
-  setFilters: () => { },
+  setFilters: noop,
   activeTab: '',
-  setActiveTab: () => { },
+  setActiveTab: noop,
   options: [],
 })
 

web/app/components/plugins/plugin-page/empty/index.tsx

 import { useInstalledPluginList } from '@/service/use-plugins'
 import { useTranslation } from 'react-i18next'
 import { SUPPORT_INSTALL_LOCAL_FILE_EXTENSIONS } from '@/config'
+import { noop } from 'lodash-es'
 
 const Empty = () => {
   const { t } = useTranslation()
           </div>
         </div>
         {selectedAction === 'github' && <InstallFromGitHub
-          onSuccess={() => { }}
+          onSuccess={noop}
           onClose={() => setSelectedAction(null)}
         />}
         {selectedAction === 'local' && selectedFile
           && (<InstallFromLocalPackage
             file={selectedFile}
             onClose={() => setSelectedAction(null)}
-            onSuccess={() => { }}
+            onSuccess={noop}
           />
           )
         }

web/app/components/plugins/plugin-page/index.tsx

 import { SUPPORT_INSTALL_LOCAL_FILE_EXTENSIONS } from '@/config'
 import { LanguagesSupported } from '@/i18n/language'
 import I18n from '@/context/i18n'
+import { noop } from 'lodash-es'
 
 const PACKAGE_IDS_KEY = 'package-ids'
 const BUNDLE_INFO_KEY = 'bundle-info'
           {currentFile && (
             <InstallFromLocalPackage
               file={currentFile}
-              onClose={removeFile ?? (() => { })}
-              onSuccess={() => { }}
+              onClose={removeFile ?? noop}
+              onSuccess={noop}
             />
           )}
           <input
             type="file"
             id="fileUploader"
             accept={SUPPORT_INSTALL_LOCAL_FILE_EXTENSIONS}
-            onChange={fileChangeHandle ?? (() => { })}
+            onChange={fileChangeHandle ?? noop}
           />
         </>
       )}

web/app/components/plugins/plugin-page/install-plugin-dropdown.tsx

 import { useSelector as useAppContextSelector } from '@/context/app-context'
 import { useTranslation } from 'react-i18next'
 import { SUPPORT_INSTALL_LOCAL_FILE_EXTENSIONS } from '@/config'
+import { noop } from 'lodash-es'
 
 type Props = {
   onSwitchToMarketplaceTab: () => void
         </PortalToFollowElemContent>
       </div>
       {selectedAction === 'github' && <InstallFromGitHub
-        onSuccess={() => { }}
+        onSuccess={noop}
         onClose={() => setSelectedAction(null)}
       />}
       {selectedAction === 'local' && selectedFile
         && (<InstallFromLocalPackage
           file={selectedFile}
           onClose={() => setSelectedAction(null)}
-          onSuccess={() => { }}
+          onSuccess={noop}
         />
         )
       }

web/app/components/tools/labels/selector.tsx

 import Checkbox from '@/app/components/base/checkbox'
 import type { Label } from '@/app/components/tools/labels/constant'
 import { useTags } from '@/app/components/plugins/hooks'
+import { noop } from 'lodash-es'
 
 type LabelSelectorProps = {
   value: string[]
                   <Checkbox
                     className='shrink-0'
                     checked={value.includes(label.name)}
-                    onCheck={() => { }}
+                    onCheck={noop}
                   />
                   <div title={label.label} className='grow truncate text-sm leading-5 text-text-secondary'>{label.label}</div>
                 </div>

web/app/components/tools/setting/build-in/config-credentials.tsx

 import Form from '@/app/components/header/account-setting/model-provider-page/model-modal/Form'
 import { LinkExternal02 } from '@/app/components/base/icons/src/vender/line/general'
 import { useLanguage } from '@/app/components/header/account-setting/model-provider-page/hooks'
+import { noop } from 'lodash-es'
 
 type Props = {
   collection: Collection
   onCancel,
   onSaved,
   isHideRemoveBtn,
-  onRemove = () => { },
+  onRemove = noop,
   isSaving,
 }) => {
   const { t } = useTranslation()

web/app/components/tools/workflow-tool/confirm-modal/index.tsx

 import Button from '@/app/components/base/button'
 import Modal from '@/app/components/base/modal'
 import { AlertTriangle } from '@/app/components/base/icons/src/vender/solid/alertsAndFeedback'
+import { noop } from 'lodash-es'
 
 type ConfirmModalProps = {
   show: boolean
     <Modal
       className={cn('w-[600px] max-w-[600px] p-8')}
       isShow={show}
-      onClose={() => { }}
+      onClose={noop}
     >
       <div className='absolute right-4 top-4 cursor-pointer p-2' onClick={onClose}>
         <RiCloseLine className='h-4 w-4 text-text-tertiary' />

web/app/components/workflow/dsl-export-confirm-modal.tsx

 import Checkbox from '@/app/components/base/checkbox'
 import Button from '@/app/components/base/button'
 import type { EnvironmentVariable } from '@/app/components/workflow/types'
+import { noop } from 'lodash-es'
 
 export type DSLExportConfirmModalProps = {
   envList: EnvironmentVariable[]
   return (
     <Modal
       isShow={true}
-      onClose={() => { }}
+      onClose={noop}
       className={cn('w-[480px] max-w-[480px]')}
     >
       <div className='title-2xl-semi-bold relative pb-6 text-text-primary'>{t('workflow.env.export.title')}</div>

web/app/components/workflow/nodes/_base/components/editor/code-editor/index.tsx

 import {
   getFilesInLogs,
 } from '@/app/components/base/file-uploader/utils'
-
 import './style.css'
+import { noop } from 'lodash-es'
 
 // load file from local instead of cdn https://github.com/suren-atoyan/monaco-react/issues/482
 loader.config({ paths: { vs: '/vs' } })
 const CodeEditor: FC<Props> = ({
   value = '',
   placeholder = '',
-  onChange = () => { },
+  onChange = noop,
   title = '',
   headerRight,
   language,

web/app/components/workflow/nodes/_base/components/file-type-item.tsx

 import TagInput from '@/app/components/base/tag-input'
 import Checkbox from '@/app/components/base/checkbox'
 import { FileTypeIcon } from '@/app/components/base/file-uploader'
+import { noop } from 'lodash-es'
 
 type Props = {
   type: SupportUploadFileTypes.image | SupportUploadFileTypes.document | SupportUploadFileTypes.audio | SupportUploadFileTypes.video | SupportUploadFileTypes.custom
   selected,
   onToggle,
   customFileTypes = [],
-  onCustomFileTypesChange = () => { },
+  onCustomFileTypesChange = noop,
 }) => {
   const { t } = useTranslation()
 

web/app/components/workflow/nodes/_base/components/input-support-select-var.tsx

 import PromptEditor from '@/app/components/base/prompt-editor'
 import { Variable02 } from '@/app/components/base/icons/src/vender/solid/development'
 import Tooltip from '@/app/components/base/tooltip'
+import { noop } from 'lodash-es'
 
 type Props = {
   instanceId?: string
             show: false,
             selectable: false,
             datasets: [],
-            onAddContext: () => { },
+            onAddContext: noop,
           }}
           historyBlock={{
             show: false,
               user: 'Human',
               assistant: 'Assistant',
             },
-            onEditRole: () => { },
+            onEditRole: noop,
           }}
           queryBlock={{
             show: false,

web/app/components/workflow/nodes/_base/components/variable/var-reference-picker.tsx

 import Badge from '@/app/components/base/badge'
 import Tooltip from '@/app/components/base/tooltip'
 import { isExceptionVariable } from '@/app/components/workflow/utils'
+import { noop } from 'lodash-es'
 
 const TRIGGER_DEFAULT_WIDTH = 227
 
   className,
   isShowNodeName = true,
   value = [],
-  onOpen = () => { },
+  onOpen = noop,
   onChange,
   isSupportConstantValue,
   defaultVarKindType = VarKindType.constant,
             {isAddBtnTrigger
               ? (
                 <div>
-                  <AddButton onClick={() => { }}></AddButton>
+                  <AddButton onClick={noop}></AddButton>
                 </div>
               )
               : (<div ref={!isSupportConstantValue ? triggerRef : null} className={cn((open || isFocus) ? 'border-gray-300' : 'border-gray-100', 'group/wrap relative flex h-8 w-full items-center', !isSupportConstantValue && 'rounded-lg bg-components-input-bg-normal p-1', isInTable && 'border-none bg-transparent', readonly && 'bg-components-input-bg-disabled')}>

web/app/components/workflow/nodes/assigner/components/var-list/index.tsx

 import Input from '@/app/components/base/input'
 import Textarea from '@/app/components/base/textarea'
 import CodeEditor from '@/app/components/workflow/nodes/_base/components/editor/code-editor'
+import { noop } from 'lodash-es'
 
 type Props = {
   readonly: boolean
   nodeId,
   list,
   onChange,
-  onOpen = () => { },
+  onOpen = noop,
   filterVar,
   filterToAssignedVar,
   getAssignedVarType,

web/app/components/workflow/nodes/if-else/components/condition-wrap.tsx

 import cn from '@/utils/classnames'
 import Button from '@/app/components/base/button'
 import { PortalSelect as Select } from '@/app/components/base/select'
+import { noop } from 'lodash-es'
 
 type Props = {
   isSubVariable?: boolean
   nodeId: id = '',
   cases = [],
   readOnly,
-  handleSortCase = () => { },
+  handleSortCase = noop,
   handleRemoveCase,
   handleUpdateCondition,
   handleAddCondition,

web/app/components/workflow/nodes/knowledge-retrieval/components/metadata/metadata-filter/index.tsx

 import type { MetadataShape } from '@/app/components/workflow/nodes/knowledge-retrieval/types'
 import { MetadataFilteringModeEnum } from '@/app/components/workflow/nodes/knowledge-retrieval/types'
 import ModelParameterModal from '@/app/components/header/account-setting/model-provider-page/model-parameter-modal'
+import { noop } from 'lodash-es'
 
 type MetadataFilterProps = {
   metadataFilterMode?: MetadataFilteringModeEnum
                   provider={metadataModelConfig?.provider || ''}
                   completionParams={metadataModelConfig?.completion_params || { temperature: 0.7 }}
                   modelId={metadataModelConfig?.name || ''}
-                  setModel={handleMetadataModelChange || (() => {})}
-                  onCompletionParamsChange={handleMetadataCompletionParamsChange || (() => {})}
+                  setModel={handleMetadataModelChange || noop}
+                  onCompletionParamsChange={handleMetadataCompletionParamsChange || noop}
                   hideDebugWithMultipleModel
                   debugWithMultipleModel={false}
                 />

web/app/components/workflow/nodes/start/components/var-item.tsx

 import { Edit03 } from '@/app/components/base/icons/src/vender/solid/general'
 import Badge from '@/app/components/base/badge'
 import ConfigVarModal from '@/app/components/app/configuration/config-var/config-modal'
+import { noop } from 'lodash-es'
 
 type Props = {
   readonly: boolean
 const VarItem: FC<Props> = ({
   readonly,
   payload,
-  onChange = () => { },
-  onRemove = () => { },
+  onChange = noop,
+  onRemove = noop,
   rightContent,
   varKeys = [],
   showLegacyBadge = false,

web/app/components/workflow/nodes/tool/components/input-var-list.tsx

 import { VarType } from '@/app/components/workflow/types'
 import AppSelector from '@/app/components/plugins/plugin-detail-panel/app-selector'
 import ModelParameterModal from '@/app/components/plugins/plugin-detail-panel/model-selector'
+import { noop } from 'lodash-es'
 
 type Props = {
   readOnly: boolean
   schema,
   value,
   onChange,
-  onOpen = () => { },
+  onOpen = noop,
   isSupportConstantValue,
   filterVar,
 }) => {

web/app/components/workflow/nodes/variable-assigner/components/var-list/index.tsx

 import VarReferencePicker from '@/app/components/workflow/nodes/_base/components/variable/var-reference-picker'
 import type { ValueSelector, Var } from '@/app/components/workflow/types'
 import { VarType as VarKindType } from '@/app/components/workflow/nodes/tool/types'
+import { noop } from 'lodash-es'
 
 type Props = {
   readonly: boolean
   nodeId,
   list,
   onChange,
-  onOpen = () => { },
+  onOpen = noop,
   filterVar,
 }) => {
   const { t } = useTranslation()

web/app/components/workflow/panel/debug-and-preview/conversation-variable-modal.tsx

 import useTimestamp from '@/hooks/use-timestamp'
 import { fetchCurrentValueOfConversationVariable } from '@/service/workflow'
 import cn from '@/utils/classnames'
+import { noop } from 'lodash-es'
 
 export type Props = {
   conversationID: string
   return (
     <Modal
       isShow
-      onClose={() => { }}
+      onClose={noop}
       className={cn('h-[640px] w-[920px] max-w-[920px] p-0')}
     >
       <div className='absolute right-4 top-4 cursor-pointer p-2' onClick={onHide}>

web/app/components/workflow/panel/debug-and-preview/index.tsx

 import Tooltip from '@/app/components/base/tooltip'
 import ActionButton, { ActionButtonState } from '@/app/components/base/action-button'
 import { useStore } from '@/app/components/workflow/store'
+import { noop } from 'lodash-es'
 
 export type ChatWrapperRefType = {
   handleRestart: () => void
 }
 const DebugAndPreview = () => {
   const { t } = useTranslation()
-  const chatRef = useRef({ handleRestart: () => { } })
+  const chatRef = useRef({ handleRestart: noop })
   const { handleCancelDebugAndPreviewPanel } = useWorkflowInteractions()
   const { handleNodeCancelRunningStatus } = useNodesInteractions()
   const { handleEdgeCancelRunningStatus } = useEdgesInteractions()

web/app/components/workflow/run/utils/format-log/iteration/index.spec.ts

 import format from '.'
 import graphToLogStruct from '../graph-to-log-struct'
+import { noop } from 'lodash-es'
 
 describe('iteration', () => {
   const list = graphToLogStruct('start -> (iteration, iterationNode, plainNode1 -> plainNode2)')
   // const [startNode, iterationNode, ...iterations] = list
-  const result = format(list as any, () => { })
+  const result = format(list as any, noop)
   test('result should have no nodes in iteration node', () => {
     expect((result as any).find((item: any) => !!item.execution_metadata?.iteration_id)).toBeUndefined()
   })

web/app/components/workflow/run/utils/format-log/loop/index.spec.ts

 import format from '.'
 import graphToLogStruct from '../graph-to-log-struct'
+import { noop } from 'lodash-es'
 
 describe('loop', () => {
   const list = graphToLogStruct('start -> (loop, loopNode, plainNode1 -> plainNode2)')
   const [startNode, loopNode, ...loops] = list
-  const result = format(list as any, () => { })
+  const result = format(list as any, noop)
   test('result should have no nodes in loop node', () => {
     expect((result as any).find((item: any) => !!item.execution_metadata?.loop_id)).toBeUndefined()
   })

web/app/components/workflow/workflow-history-store.tsx

 import isDeepEqual from 'fast-deep-equal'
 import type { Edge, Node } from './types'
 import type { WorkflowHistoryEvent } from './hooks'
+import { noop } from 'lodash-es'
 
-export const WorkflowHistoryStoreContext = createContext<WorkflowHistoryStoreContextType>({ store: null, shortcutsEnabled: true, setShortcutsEnabled: () => {} })
+export const WorkflowHistoryStoreContext = createContext<WorkflowHistoryStoreContextType>({ store: null, shortcutsEnabled: true, setShortcutsEnabled: noop })
 export const Provider = WorkflowHistoryStoreContext.Provider
 
 export function WorkflowHistoryProvider({

web/app/education-apply/education-apply-page.tsx

 import { useToastContext } from '@/app/components/base/toast'
 import { EDUCATION_VERIFYING_LOCALSTORAGE_ITEM } from '@/app/education-apply/constants'
 import { getLocaleOnClient } from '@/i18n'
+import { noop } from 'lodash-es'
 
 const EducationApplyAge = () => {
   const { t } = useTranslation()
   const {
     isPending,
     mutateAsync: educationAdd,
-  } = useEducationAdd({ onSuccess: () => {} })
+  } = useEducationAdd({ onSuccess: noop })
   const [modalShow, setShowModal] = useState<undefined | { title: string; desc: string; onConfirm?: () => void }>(undefined)
   const { onPlanInfoChanged } = useProviderContext()
   const updateEducationStatus = useInvalidateEducationStatus()
         isShow={!!modalShow}
         title={modalShow?.title || ''}
         content={modalShow?.desc}
-        onConfirm={modalShow?.onConfirm || (() => {})}
-        onCancel={modalShow?.onConfirm || (() => {})}
+        onConfirm={modalShow?.onConfirm || noop}
+        onCancel={modalShow?.onConfirm || noop}
       />
     </div>
   )

web/app/reset-password/page.tsx

 import Toast from '@/app/components/base/toast'
 import { sendResetPasswordCode } from '@/service/common'
 import I18NContext from '@/context/i18n'
+import { noop } from 'lodash-es'
 
 export default function CheckCode() {
   const { t } = useTranslation()
       </p>
     </div>
 
-    <form onSubmit={() => { }}>
+    <form onSubmit={noop}>
       <input type='text' className='hidden' />
       <div className='mb-2'>
         <label htmlFor="email" className='system-md-semibold my-2 text-text-secondary'>{t('login.email')}</label>

web/app/signin/components/mail-and-code-auth.tsx

 import { sendEMailLoginCode } from '@/service/common'
 import { COUNT_DOWN_KEY, COUNT_DOWN_TIME_MS } from '@/app/components/signin/countdown'
 import I18NContext from '@/context/i18n'
+import { noop } from 'lodash-es'
 
 type MailAndCodeAuthProps = {
   isInvite: boolean
     }
   }
 
-  return (<form onSubmit={() => { }}>
+  return (<form onSubmit={noop}>
     <input type='text' className='hidden' />
     <div className='mb-2'>
       <label htmlFor="email" className='system-md-semibold my-2 text-text-secondary'>{t('login.email')}</label>

web/app/signin/components/mail-and-password-auth.tsx

 import { login } from '@/service/common'
 import Input from '@/app/components/base/input'
 import I18NContext from '@/context/i18n'
+import { noop } from 'lodash-es'
 
 type MailAndPasswordAuthProps = {
   isInvite: boolean
     }
   }
 
-  return <form onSubmit={() => { }}>
+  return <form onSubmit={noop}>
     <div className='mb-3'>
       <label htmlFor="email" className="system-md-semibold my-2 text-text-secondary">
         {t('login.email')}

web/context/app-context.tsx

 import MaintenanceNotice from '@/app/components/header/maintenance-notice'
 import type { SystemFeatures } from '@/types/feature'
 import { defaultSystemFeatures } from '@/types/feature'
+import { noop } from 'lodash-es'
 
 export type AppContextValue = {
   apps: App[]
 const AppContext = createContext<AppContextValue>({
   systemFeatures: defaultSystemFeatures,
   apps: [],
-  mutateApps: () => { },
+  mutateApps: noop,
   userProfile: {
     id: '',
     name: '',
   isCurrentWorkspaceOwner: false,
   isCurrentWorkspaceEditor: false,
   isCurrentWorkspaceDatasetOperator: false,
-  mutateUserProfile: () => { },
-  mutateCurrentWorkspace: () => { },
+  mutateUserProfile: noop,
+  mutateCurrentWorkspace: noop,
   pageContainerRef: createRef(),
   langeniusVersionInfo: initialLangeniusVersionInfo,
   useSelector,

web/context/datasets-context.tsx

 
 import { createContext, useContext } from 'use-context-selector'
 import type { DataSet } from '@/models/datasets'
+import { noop } from 'lodash-es'
 
 export type DatasetsContextValue = {
   datasets: DataSet[]
 
 const DatasetsContext = createContext<DatasetsContextValue>({
   datasets: [],
-  mutateDatasets: () => {},
+  mutateDatasets: noop,
   currentDataset: undefined,
 })
 

web/context/debug-configuration.ts

 import { ANNOTATION_DEFAULT, DEFAULT_AGENT_SETTING, DEFAULT_CHAT_PROMPT_CONFIG, DEFAULT_COMPLETION_PROMPT_CONFIG } from '@/config'
 import type { FormValue } from '@/app/components/header/account-setting/model-provider-page/declarations'
 import type { Collection } from '@/app/components/tools/types'
+import { noop } from 'lodash-es'
 
 type IDebugConfiguration = {
   appId: string
   mode: '',
   modelModeType: ModelModeType.chat,
   promptMode: PromptMode.simple,
-  setPromptMode: () => { },
+  setPromptMode: noop,
   isAdvancedMode: false,
   isAgent: false,
   isFunctionCall: false,
   isOpenAI: false,
   collectionList: [],
   canReturnToSimpleMode: false,
-  setCanReturnToSimpleMode: () => { },
+  setCanReturnToSimpleMode: noop,
   chatPromptConfig: DEFAULT_CHAT_PROMPT_CONFIG,
   completionPromptConfig: DEFAULT_COMPLETION_PROMPT_CONFIG,
   currentAdvancedPrompt: [],
-  showHistoryModal: () => { },
+  showHistoryModal: noop,
   conversationHistoriesRole: {
     user_prefix: 'user',
     assistant_prefix: 'assistant',
   },
-  setConversationHistoriesRole: () => { },
-  setCurrentAdvancedPrompt: () => { },
+  setConversationHistoriesRole: noop,
+  setCurrentAdvancedPrompt: noop,
   hasSetBlockStatus: {
     context: false,
     history: false,
     query: false,
   },
   conversationId: '',
-  setConversationId: () => { },
+  setConversationId: noop,
   introduction: '',
-  setIntroduction: () => { },
+  setIntroduction: noop,
   suggestedQuestions: [],
-  setSuggestedQuestions: () => { },
+  setSuggestedQuestions: noop,
   controlClearChatMessage: 0,
-  setControlClearChatMessage: () => { },
+  setControlClearChatMessage: noop,
   prevPromptConfig: {
     prompt_template: '',
     prompt_variables: [],
   },
-  setPrevPromptConfig: () => { },
+  setPrevPromptConfig: noop,
   moreLikeThisConfig: {
     enabled: false,
   },
-  setMoreLikeThisConfig: () => { },
+  setMoreLikeThisConfig: noop,
   suggestedQuestionsAfterAnswerConfig: {
     enabled: false,
   },
-  setSuggestedQuestionsAfterAnswerConfig: () => { },
+  setSuggestedQuestionsAfterAnswerConfig: noop,
   speechToTextConfig: {
     enabled: false,
   },
-  setSpeechToTextConfig: () => { },
+  setSpeechToTextConfig: noop,
   textToSpeechConfig: {
     enabled: false,
     voice: '',
     language: '',
   },
-  setTextToSpeechConfig: () => { },
+  setTextToSpeechConfig: noop,
   citationConfig: {
     enabled: false,
   },
-  setCitationConfig: () => { },
+  setCitationConfig: noop,
   moderationConfig: {
     enabled: false,
   },
       embedding_provider_name: '',
     },
   },
-  setAnnotationConfig: () => { },
-  setModerationConfig: () => { },
+  setAnnotationConfig: noop,
+  setModerationConfig: noop,
   externalDataToolsConfig: [],
-  setExternalDataToolsConfig: () => { },
+  setExternalDataToolsConfig: noop,
   formattingChanged: false,
-  setFormattingChanged: () => { },
+  setFormattingChanged: noop,
   inputs: {},
-  setInputs: () => { },
+  setInputs: noop,
   query: '',
-  setQuery: () => { },
+  setQuery: noop,
   completionParams: {
     max_tokens: 16,
     temperature: 1, // 0-2
     presence_penalty: 1, // -2-2
     frequency_penalty: 1, // -2-2
   },
-  setCompletionParams: () => { },
+  setCompletionParams: noop,
   modelConfig: {
     provider: 'OPENAI', // 'OPENAI'
     model_id: 'gpt-3.5-turbo', // 'gpt-3.5-turbo'
     dataSets: [],
     agentConfig: DEFAULT_AGENT_SETTING,
   },
-  setModelConfig: () => { },
+  setModelConfig: noop,
   dataSets: [],
-  showSelectDataSet: () => { },
-  setDataSets: () => { },
+  showSelectDataSet: noop,
+  setDataSets: noop,
   datasetConfigs: {
     retrieval_model: RETRIEVE_TYPE.multiWay,
     reranking_model: {
   datasetConfigsRef: {
     current: null,
   },
-  setDatasetConfigs: () => { },
+  setDatasetConfigs: noop,
   hasSetContextVar: false,
   isShowVisionConfig: false,
   visionConfig: {
     detail: Resolution.low,
     transfer_methods: [TransferMethod.remote_url],
   },
-  setVisionConfig: () => { },
+  setVisionConfig: noop,
   isAllowVideoUpload: false,
   isShowDocumentConfig: false,
   rerankSettingModalOpen: false,
-  setRerankSettingModalOpen: () => { },
+  setRerankSettingModalOpen: noop,
 })
 
 export const useDebugConfigurationContext = () => useContext(DebugConfigurationContext)

web/context/explore-context.ts

 import { createContext } from 'use-context-selector'
 import type { InstalledApp } from '@/models/explore'
+import { noop } from 'lodash-es'
 
 type IExplore = {
   controlUpdateInstalledApps: number
 
 const ExploreContext = createContext<IExplore>({
   controlUpdateInstalledApps: 0,
-  setControlUpdateInstalledApps: () => { },
+  setControlUpdateInstalledApps: noop,
   hasEditPermission: false,
   installedApps: [],
-  setInstalledApps: () => { },
+  setInstalledApps: noop,
 })
 
 export default ExploreContext

web/context/modal-context.tsx

 import type { UpdatePluginPayload } from '@/app/components/plugins/types'
 import UpdatePlugin from '@/app/components/plugins/update-plugin'
 import { removeSpecificQueryParam } from '@/utils'
+import { noop } from 'lodash-es'
 
 export type ModalState<T> = {
   payload: T
   setShowUpdatePluginModal: Dispatch<SetStateAction<ModalState<UpdatePluginPayload> | null>>
 }
 const ModalContext = createContext<ModalContextState>({
-  setShowAccountSettingModal: () => { },
-  setShowApiBasedExtensionModal: () => { },
-  setShowModerationSettingModal: () => { },
-  setShowExternalDataToolModal: () => { },
-  setShowPricingModal: () => { },
-  setShowAnnotationFullModal: () => { },
-  setShowModelModal: () => { },
-  setShowExternalKnowledgeAPIModal: () => { },
-  setShowModelLoadBalancingModal: () => { },
-  setShowModelLoadBalancingEntryModal: () => { },
-  setShowOpeningModal: () => { },
-  setShowUpdatePluginModal: () => { },
+  setShowAccountSettingModal: noop,
+  setShowApiBasedExtensionModal: noop,
+  setShowModerationSettingModal: noop,
+  setShowExternalDataToolModal: noop,
+  setShowPricingModal: noop,
+  setShowAnnotationFullModal: noop,
+  setShowModelModal: noop,
+  setShowExternalKnowledgeAPIModal: noop,
+  setShowModelLoadBalancingModal: noop,
+  setShowModelLoadBalancingEntryModal: noop,
+  setShowOpeningModal: noop,
+  setShowUpdatePluginModal: noop,
 })
 
 export const useModalContext = () => useContext(ModalContext)

web/context/provider-context.tsx

 import {
   useEducationStatus,
 } from '@/service/use-education'
+import { noop } from 'lodash-es'
 
 type ProviderContextState = {
   modelProviders: ModelProvider[]
 }
 const ProviderContext = createContext<ProviderContextState>({
   modelProviders: [],
-  refreshModelProviders: () => { },
+  refreshModelProviders: noop,
   textGenerationModelList: [],
   supportRetrievalMethods: [],
   isAPIKeySet: true,
   },
   isFetchedPlan: false,
   enableBilling: false,
-  onPlanInfoChanged: () => { },
+  onPlanInfoChanged: noop,
   enableReplaceWebAppLogo: false,
   modelLoadBalancingEnabled: false,
   datasetOperatorEnabled: false,