lint: fix issue of no-unused-vars (#23375)

web/app/(commonLayout)/datasets/create/page.tsx

 import React from 'react'
 import DatasetUpdateForm from '@/app/components/datasets/create'
 
-type Props = {}
-
-const DatasetCreation = async (props: Props) => {
+const DatasetCreation = async () => {
   return (
     <DatasetUpdateForm />
   )

web/app/components/app/annotation/header-opts/index.tsx

       await clearAllAnnotations(appId)
       onAdded()
     }
-    catch (_) {
+    catch (e) {
+      console.error(`failed to clear all annotations, ${e}`)
     }
     finally {
       setShowClearConfirm(false)

web/app/components/workflow/nodes/answer/utils.ts

 import type { AnswerNodeType } from './types'
 
-export const checkNodeValid = (payload: AnswerNodeType) => {
+export const checkNodeValid = (_payload: AnswerNodeType) => {
   return true
 }

web/app/components/workflow/nodes/assigner/utils.ts

 import type { AssignerNodeType } from './types'
 import { AssignerNodeInputType, WriteMode } from './types'
 
-export const checkNodeValid = (payload: AssignerNodeType) => {
+export const checkNodeValid = (_payload: AssignerNodeType) => {
   return true
 }
 

web/app/components/workflow/nodes/end/utils.ts

 import type { EndNodeType } from './types'
 
-export const checkNodeValid = (payload: EndNodeType) => {
+export const checkNodeValid = (_payload: EndNodeType) => {
   return true
 }

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

       onRemoveCondition?.(caseId, condition.id)
   }, [caseId, condition, conditionId, isSubVariableKey, onRemoveCondition, onRemoveSubVariableCondition])
 
-  const handleVarChange = useCallback((valueSelector: ValueSelector, varItem: Var) => {
+  const handleVarChange = useCallback((valueSelector: ValueSelector, _varItem: Var) => {
     const resolvedVarType = getVarType({
       valueSelector,
       availableNodes,

web/app/components/workflow/nodes/llm/panel.tsx

           Toast.notify({ type: 'warning', message: `${t('common.modelProvider.parametersInvalidRemoved')}: ${keys.map(k => `${k} (${removedDetails[k]})`).join(', ')}` })
         handleCompletionParamsChange(filtered)
       }
-      catch (e) {
+      catch {
         Toast.notify({ type: 'error', message: t('common.error') })
         handleCompletionParamsChange({})
       }

web/app/components/workflow/nodes/llm/utils.ts

 import produce from 'immer'
 import { z } from 'zod'
 
-export const checkNodeValid = (payload: LLMNodeType) => {
+export const checkNodeValid = (_payload: LLMNodeType) => {
   return true
 }
 
 
 export const validateSchemaAgainstDraft7 = (schemaToValidate: any) => {
   const schema = produce(schemaToValidate, (draft: any) => {
-  // Make sure the schema has the $schema property for draft-07
+    // Make sure the schema has the $schema property for draft-07
     if (!draft.$schema)
       draft.$schema = 'http://json-schema.org/draft-07/schema#'
   })

web/app/components/workflow/nodes/loop/use-config.ts

 import { v4 as uuid4 } from 'uuid'
 import {
   useIsChatMode,
-  useIsNodeInLoop,
   useNodesReadOnly,
   useWorkflow,
 } from '../../hooks'
 import useIsVarFileAttribute from './use-is-var-file-attribute'
 import { useStore } from '@/app/components/workflow/store'
 
-const DELIMITER = '@@@@@'
 const useConfig = (id: string, payload: LoopNodeType) => {
   const { nodesReadOnly: readOnly } = useNodesReadOnly()
-  const { isNodeInLoop } = useIsNodeInLoop(id)
   const isChatMode = useIsChatMode()
   const conversationVariables = useStore(s => s.conversationVariables)
 
   }, [])
 
   // output
-  const { getLoopNodeChildren, getBeforeNodesInSameBranch } = useWorkflow()
-  const beforeNodes = getBeforeNodesInSameBranch(id)
+  const { getLoopNodeChildren } = useWorkflow()
   const loopChildrenNodes = [{ id, data: payload } as any, ...getLoopNodeChildren(id)]
-  const canChooseVarNodes = [...beforeNodes, ...loopChildrenNodes]
   const childrenNodeVars = toNodeOutputVars(loopChildrenNodes, isChatMode, undefined, [], conversationVariables)
 
   const {

web/app/components/workflow/nodes/start/utils.ts

 import type { StartNodeType } from './types'
 
-export const checkNodeValid = (payload: StartNodeType) => {
+export const checkNodeValid = (_payload: StartNodeType) => {
   return true
 }

web/app/components/workflow/nodes/template-transform/utils.ts

 import type { TemplateTransformNodeType } from './types'
 
-export const checkNodeValid = (payload: TemplateTransformNodeType) => {
+export const checkNodeValid = (_payload: TemplateTransformNodeType) => {
   return true
 }

web/app/components/workflow/nodes/tool/utils.ts

 import type { ToolNodeType } from './types'
 
-export const checkNodeValid = (payload: ToolNodeType) => {
+export const checkNodeValid = (_payload: ToolNodeType) => {
   return true
 }

web/app/components/workflow/store/workflow/debug/inspect-vars-slice.ts

 
 export type InspectVarsSliceShape = InspectVarsState & InspectVarsActions
 
-export const createInspectVarsSlice: StateCreator<InspectVarsSliceShape> = (set, get) => {
+export const createInspectVarsSlice: StateCreator<InspectVarsSliceShape> = (set) => {
   return ({
     currentFocusNodeId: null,
     nodesWithInspectVars: [],
           if (!targetNode)
             return
           const targetVar = targetNode.vars.find(varItem => varItem.id === varId)
-          if(!targetVar)
+          if (!targetVar)
             return
           targetVar.value = value
           targetVar.edited = true
-          },
+        },
         )
         return {
           nodesWithInspectVars: nodes,
           if (!targetNode)
             return
           const targetVar = targetNode.vars.find(varItem => varItem.id === varId)
-          if(!targetVar)
+          if (!targetVar)
             return
           targetVar.value = value
           targetVar.edited = false
-          },
+        },
         )
         return {
           nodesWithInspectVars: nodes,
           if (!targetNode)
             return
           const targetVar = targetNode.vars.find(varItem => varItem.id === varId)
-          if(!targetVar)
+          if (!targetVar)
             return
           targetVar.name = selector[1]
           targetVar.selector = selector
-          },
+        },
         )
         return {
           nodesWithInspectVars: nodes,
           const needChangeVarIndex = targetNode.vars.findIndex(varItem => varItem.id === varId)
           if (needChangeVarIndex !== -1)
             targetNode.vars.splice(needChangeVarIndex, 1)
-          },
+        },
         )
         return {
           nodesWithInspectVars: nodes,

web/eslint.config.mjs

       '**/.next/',
       '**/public/*',
       '**/*.json',
+      '**/*.js',
     ],
   },
   {