Vertaal 56 Engelse foutteksten in de Nederlandse interface

Deze verschenen zodra de backend geen eigen melding meegaf: de terugvalteksten
van formatError en de controles vóór een handeling. Een operator kreeg dan
"Failed to load exports" of "Select a project first" te zien, midden in een
verder Nederlandse werkbank.

Dit is geen meertaligheidsvraagstuk maar inconsistentie binnen de taal die het
product al spreekt. De teksten volgen nu de bestaande toon: benoemen wat er
misging of wat er eerst nodig is, in actieve vorm, zonder excuus.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

frontend/src/hooks/useChangeDetectionWorkflow.ts

@@ -38,7 +38,7 @@ export function useChangeDetectionWorkflow({
     const targetDatasetId =
       changeTargetDatasetId || availableVectorDatasets.find((dataset) => dataset.id !== sourceDatasetId)?.id
     if (!sourceDatasetId || !targetDatasetId) {
-      setChangeDetectionError('Select two vector datasets')
+      setChangeDetectionError('Kies twee vectorbronnen')
       return
     }
     if (sourceDatasetId === targetDatasetId) {

frontend/src/hooks/useDatasetWorkflow.ts

@@ -230,15 +230,15 @@ export function useDatasetWorkflow({
   const uploadDataset = async (event: FormEvent) => {
     event.preventDefault()
     if (!selectedProjectId || !datasetForm.file) {
-      setErrorMessage('Select project and upload a file')
+      setErrorMessage('Kies een werkruimte en voeg een bestand toe')
       return
     }
     if (!datasetForm.datasetRole) {
-      setErrorMessage('Select dataset role')
+      setErrorMessage('Kies de rol van deze bron')
       return
     }
     if (datasetForm.datasetRole === 'reference' && datasetForm.datasetType !== 'vector' && datasetForm.datasetType !== 'geojson') {
-      setErrorMessage('Reference role requires vector dataset upload')
+      setErrorMessage('Een referentierol vraagt om een vectorbestand')
       return
     }
     if (datasetForm.sourceMetadataJson) {
@@ -280,7 +280,7 @@ export function useDatasetWorkflow({
       setDatasetForm((previous) => ({ ...previous, file: null }))
       await loadProjectData(selectedProjectId)
     } catch (error) {
-      setErrorMessage(error instanceof Error ? error.message : 'Failed to upload dataset')
+      setErrorMessage(error instanceof Error ? error.message : 'De bron kon niet worden ingeladen')
     }
   }
 
@@ -300,7 +300,7 @@ export function useDatasetWorkflow({
       return
     }
     if (!selectedClipAreaId) {
-      setDatasetDetailError('Select an area for clipping')
+      setDatasetDetailError('Kies eerst een gebied om op bij te snijden')
       return
     }
     setDatasetDetailError(null)
@@ -337,7 +337,7 @@ export function useDatasetWorkflow({
     }
     const targetId = selectedIntersectTargetId || availableVectorTargets[0]?.id
     if (!targetId) {
-      setDatasetDetailError('Select an intersect target dataset')
+      setDatasetDetailError('Kies eerst een bron om mee te doorsnijden')
       return
     }
     setDatasetDetailError(null)
@@ -421,7 +421,7 @@ export function useDatasetWorkflow({
       return
     }
     if (!selectedClipAreaId) {
-      setDatasetDetailError('Select an area for raster clip')
+      setDatasetDetailError('Kies eerst een gebied om het raster op bij te snijden')
       return
     }
     try {

frontend/src/hooks/useDetectionWorkflow.ts

@@ -146,7 +146,7 @@ export function useDetectionWorkflow({
         setSelectedDetectionModelId(configuredModel?.model_id ?? response.models[0].model_id)
       }
     } catch (error) {
-      setDetectionModelError(formatError(error, 'Failed to load detection models'))
+      setDetectionModelError(formatError(error, 'De detectiemodellen konden niet worden geladen'))
     }
     try {
       const assetResponse = await detectionApi.listModelAssets()
@@ -160,11 +160,11 @@ export function useDetectionWorkflow({
         setYoloPreflight(preflight)
         setYoloPreflightError(null)
       } catch (error) {
-        setYoloPreflightError(formatError(error, 'Failed to load YOLO preflight status'))
+        setYoloPreflightError(formatError(error, 'De modelcontrole kon niet worden opgehaald'))
       }
     } catch (error) {
       setModelAssets([])
-      setModelAssetError(formatError(error, 'Failed to load local model assets'))
+      setModelAssetError(formatError(error, 'De lokale modelbestanden konden niet worden geladen'))
     } finally {
       setLoadingDetectionModels(false)
     }
@@ -180,7 +180,7 @@ export function useDetectionWorkflow({
       })
       setYoloPreflight(response)
     } catch (error) {
-      setYoloPreflightError(formatError(error, 'Failed to load YOLO preflight status'))
+      setYoloPreflightError(formatError(error, 'De modelcontrole kon niet worden opgehaald'))
     } finally {
       setLoadingYoloPreflight(false)
     }
@@ -198,7 +198,7 @@ export function useDetectionWorkflow({
         setSelectedDetectionRunId(response.items[0].id)
       }
     } catch (error) {
-      setDetectionRunError(formatError(error, 'Failed to load detection runs'))
+      setDetectionRunError(formatError(error, 'De detectieruns konden niet worden geladen'))
     }
   }
 
@@ -229,7 +229,7 @@ export function useDetectionWorkflow({
       setDetectionTruncated(Boolean(detectionsResponse.truncated))
       setDetectionGeoJson(geoJsonResponse)
     } catch (error) {
-      setDetectionRunError(formatError(error, 'Failed to load detection results'))
+      setDetectionRunError(formatError(error, 'De detectieresultaten konden niet worden geladen'))
     } finally {
       setLoadingDetectionResults(false)
     }
@@ -262,12 +262,12 @@ export function useDetectionWorkflow({
 
   const runDetection = async () => {
     if (!selectedProjectId) {
-      setDetectionRunError('Select a project first')
+      setDetectionRunError('Kies eerst een werkruimte')
       return
     }
     const datasetId = selectedDetectionDatasetId
     if (!datasetId) {
-      setDetectionRunError('Select a raster dataset')
+      setDetectionRunError('Kies eerst een rasterbron')
       return
     }
     setDetectionRunError(null)
@@ -414,11 +414,11 @@ export function useDetectionWorkflow({
     iouThresholdOverride?: number,
   ): Promise<DetectionQaResult | null> => {
     if (!analysisRunId) {
-      setDetectionQaError('Select a detection run')
+      setDetectionQaError('Kies eerst een detectierun')
       return null
     }
     if (!referenceDatasetId) {
-      setDetectionQaError('Select a reference dataset')
+      setDetectionQaError('Kies eerst een referentiebron')
       return null
     }
     setSelectedDetectionRunId(analysisRunId)
@@ -449,21 +449,21 @@ export function useDetectionWorkflow({
 
   const runDetectionCalibration = async () => {
     if (!selectedProjectId) {
-      setDetectionCalibrationError('Select a project before calibration')
+      setDetectionCalibrationError('Kies eerst een werkruimte om te kalibreren')
       return
     }
     const datasetId = selectedDetectionDatasetId
     if (!datasetId) {
-      setDetectionCalibrationError('Select a raster dataset before calibration')
+      setDetectionCalibrationError('Kies eerst een rasterbron om te kalibreren')
       return
     }
     if (!detectionReferenceDatasetId) {
-      setDetectionCalibrationError('Select a reference dataset before calibration')
+      setDetectionCalibrationError('Kies eerst een referentiebron om te kalibreren')
       return
     }
     const selectedModel = detectionModels.find((model) => model.model_id === selectedDetectionModelId)
     if (!selectedModel?.configured || selectedDetectionModelId === 'manual-fixture-detector') {
-      setDetectionCalibrationError('Select a configured non-fixture detection model before calibration')
+      setDetectionCalibrationError('Kies eerst een geconfigureerd detectiemodel; testgegevens kunnen niet gekalibreerd worden')
       return
     }
     if (selectedDetectionModelId === 'yolo-configured' && !detectionTileManifestPath.trim()) {
@@ -471,7 +471,7 @@ export function useDetectionWorkflow({
       return
     }
     if (selectedDetectionModelId === 'yolo-configured' && modelAssets.length > 0 && !selectedModelAssetId) {
-      setDetectionCalibrationError('Select a local model asset before calibration')
+      setDetectionCalibrationError('Kies eerst een lokaal modelbestand om te kalibreren')
       return
     }
     const thresholds = parseCalibrationThresholds(calibrationThresholdText)

frontend/src/hooks/useExportWorkflow.ts

@@ -45,7 +45,7 @@ export function useExportWorkflow({
       const response = await exportsApi.listProjectExports(projectId)
       setExports(response.items)
     } catch (error) {
-      setExportError(formatError(error, 'Failed to load exports'))
+      setExportError(formatError(error, 'De downloads konden niet worden geladen'))
     } finally {
       setLoadingExports(false)
     }
@@ -53,7 +53,7 @@ export function useExportWorkflow({
 
   const exportSelectedDatasetGeoJson = async () => {
     if (!selectedDataset || !isVectorDatasetType(selectedDataset.dataset_type)) {
-      setExportError('Select a vector dataset before exporting GeoJSON.')
+      setExportError('Kies eerst een vectorbron om als GeoJSON te bewaren.')
       return
     }
     setExporting(true)
@@ -67,7 +67,7 @@ export function useExportWorkflow({
       setLatestExport(response)
       await loadExports(selectedDataset.project_id)
     } catch (error) {
-      setExportError(formatError(error, 'Failed to export selected dataset'))
+      setExportError(formatError(error, 'De gekozen bron kon niet worden geëxporteerd'))
     } finally {
       setExporting(false)
     }
@@ -75,7 +75,7 @@ export function useExportWorkflow({
 
   const exportSelectedDetectionRunGeoJson = async () => {
     if (!selectedDetectionRunId || !selectedProjectId) {
-      setExportError('Select a detection run before exporting GeoJSON.')
+      setExportError('Kies eerst een detectierun om als GeoJSON te bewaren.')
       return
     }
     setExporting(true)
@@ -89,7 +89,7 @@ export function useExportWorkflow({
       setLatestExport(response)
       await loadExports(selectedProjectId)
     } catch (error) {
-      setExportError(formatError(error, 'Failed to export detection run'))
+      setExportError(formatError(error, 'De detectierun kon niet worden geëxporteerd'))
     } finally {
       setExporting(false)
     }
@@ -97,7 +97,7 @@ export function useExportWorkflow({
 
   const exportSelectedSegmentationRunGeoJson = async () => {
     if (!selectedSegmentationRunId || !selectedProjectId) {
-      setExportError('Select a segmentation run before exporting GeoJSON.')
+      setExportError('Kies eerst een segmentatierun om als GeoJSON te bewaren.')
       return
     }
     setExporting(true)
@@ -110,7 +110,7 @@ export function useExportWorkflow({
       setLatestExport(response)
       await loadExports(selectedProjectId)
     } catch (error) {
-      setExportError(formatError(error, 'Failed to export segmentation run'))
+      setExportError(formatError(error, 'De segmentatierun kon niet worden geëxporteerd'))
     } finally {
       setExporting(false)
     }
@@ -118,7 +118,7 @@ export function useExportWorkflow({
 
   const exportMapSelectionGeoJson = async (bbox: VectorSelectionBBox, areaId?: string) => {
     if (!selectedDataset || !isVectorDatasetType(selectedDataset.dataset_type)) {
-      setSelectionExportError('Select a vector dataset before saving an area export.')
+      setSelectionExportError('Kies eerst een vectorbron om het gebied mee te bewaren.')
       return null
     }
     setSelectionExporting(true)
@@ -137,7 +137,7 @@ export function useExportWorkflow({
       await loadExports(selectedDataset.project_id)
       return response
     } catch (error) {
-      setSelectionExportError(formatError(error, 'Failed to save area export'))
+      setSelectionExportError(formatError(error, 'De gebiedsdownload kon niet worden bewaard'))
       return null
     } finally {
       setSelectionExporting(false)
@@ -146,7 +146,7 @@ export function useExportWorkflow({
 
   const exportProjectMetadata = async () => {
     if (!selectedProjectId) {
-      setExportError('Select a project before exporting metadata.')
+      setExportError('Kies eerst een werkruimte om de projectgegevens te bewaren.')
       return
     }
     setExporting(true)
@@ -156,7 +156,7 @@ export function useExportWorkflow({
       setLatestExport(response)
       await loadExports(selectedProjectId)
     } catch (error) {
-      setExportError(formatError(error, 'Failed to export project metadata'))
+      setExportError(formatError(error, 'De projectgegevens konden niet worden geëxporteerd'))
     } finally {
       setExporting(false)
     }
@@ -164,7 +164,7 @@ export function useExportWorkflow({
 
   const exportProjectReport = async () => {
     if (!selectedProjectId) {
-      setExportError('Select a project before exporting a report.')
+      setExportError('Kies eerst een werkruimte om een rapport te maken.')
       return
     }
     setExporting(true)
@@ -174,7 +174,7 @@ export function useExportWorkflow({
       setLatestExport(response)
       await loadExports(selectedProjectId)
     } catch (error) {
-      setExportError(formatError(error, 'Failed to export project report'))
+      setExportError(formatError(error, 'Het projectrapport kon niet worden gemaakt'))
     } finally {
       setExporting(false)
     }
@@ -204,7 +204,7 @@ export function useExportWorkflow({
       const response = await exportsApi.getContent(selectedProjectId, exportId)
       setExportPreview(response.content)
     } catch (error) {
-      setExportError(formatError(error, 'Failed to load export content'))
+      setExportError(formatError(error, 'De inhoud van de download kon niet worden geladen'))
     }
   }
 

frontend/src/hooks/useMapSelectionDataset.ts

@@ -26,7 +26,7 @@ export function useMapSelectionDataset({
 
   const deriveMapSelectionDataset = async (bbox: VectorSelectionBBox, areaId?: string) => {
     if (!selectedProjectId || !selectedDataset || !isVectorDatasetType(selectedDataset.dataset_type)) {
-      setSelectionDatasetError('Select a vector dataset before saving the area as a dataset.')
+      setSelectionDatasetError('Kies eerst een vectorbron om het gebied als bron te bewaren.')
       return null
     }
     setSelectionDatasetSaving(true)
@@ -44,7 +44,7 @@ export function useMapSelectionDataset({
       setMapLayerVisible(true)
       return derived
     } catch (error) {
-      setSelectionDatasetError(formatError(error, 'Failed to save area as dataset'))
+      setSelectionDatasetError(formatError(error, 'Het gebied kon niet als bron worden bewaard'))
       return null
     } finally {
       setSelectionDatasetSaving(false)

frontend/src/hooks/useMapSelectionQa.ts

@@ -24,7 +24,7 @@ export function useMapSelectionQa({
 
   const runMapSelectionQa = async (candidateDataset = latestSelectionDataset) => {
     if (!selectedProjectId) {
-      setMapSelectionQaError('Select a project before running QA/QC.')
+      setMapSelectionQaError('Kies eerst een werkruimte om een kwaliteitscontrole te draaien.')
       return null
     }
     if (!candidateDataset) {
@@ -32,7 +32,7 @@ export function useMapSelectionQa({
       return null
     }
     if (!selectedMapQaReferenceDatasetId) {
-      setMapSelectionQaError('Select a reference dataset for QA/QC.')
+      setMapSelectionQaError('Kies eerst een referentiebron voor de kwaliteitscontrole.')
       return null
     }
     if (candidateDataset.id === selectedMapQaReferenceDatasetId) {

frontend/src/hooks/useProviderCapabilities.ts

@@ -16,7 +16,7 @@ export function useProviderCapabilities() {
       const providerResponse = await externalApi.listProviders()
       setProviderCapabilities(providerResponse.providers)
     } catch (error) {
-      setCapabilitiesError(error instanceof Error ? error.message : 'Failed to load external capabilities')
+      setCapabilitiesError(error instanceof Error ? error.message : 'De bronkoppelingen konden niet worden geladen')
     } finally {
       setLoadingCapabilities(false)
     }

frontend/src/hooks/useQualityWorkflow.ts

@@ -33,13 +33,13 @@ export function useQualityWorkflow({ selectedProjectId, loadProjectData }: Quali
       setQualityChecks(response.items)
       return response.items
     } catch (error) {
-      setQualityChecksError(formatError(error, 'Failed to load QA/QC results'))
+      setQualityChecksError(formatError(error, 'De kwaliteitscontroles konden niet worden geladen'))
     }
   }
 
   const loadQualityEvidenceGeoJson = async (qualityCheckId: string, projectId = selectedProjectId): Promise<QualityEvidenceGeoJsonResponse | null> => {
     if (!projectId) {
-      setQualityEvidenceError('Select a project first')
+      setQualityEvidenceError('Kies eerst een werkruimte')
       return null
     }
     setQualityEvidenceLoading(true)
@@ -49,7 +49,7 @@ export function useQualityWorkflow({ selectedProjectId, loadProjectData }: Quali
       setQualityEvidenceGeoJson(response)
       return response
     } catch (error) {
-      setQualityEvidenceError(formatError(error, 'Failed to load QA/QC evidence overlay'))
+      setQualityEvidenceError(formatError(error, 'De bewijslaag van de kwaliteitscontrole kon niet worden geladen'))
       return null
     } finally {
       setQualityEvidenceLoading(false)
@@ -63,15 +63,15 @@ export function useQualityWorkflow({ selectedProjectId, loadProjectData }: Quali
 
   const runQaComparison = async () => {
     if (!selectedProjectId) {
-      setQaError('Select a project first')
+      setQaError('Kies eerst een werkruimte')
       return
     }
     if (!qaCandidateDatasetId) {
-      setQaError('Select candidate dataset')
+      setQaError('Kies eerst een kandidaatbron')
       return
     }
     if (!qaReferenceDatasetId) {
-      setQaError('Select reference dataset')
+      setQaError('Kies eerst een referentiebron')
       return
     }
     if (qaCandidateDatasetId === qaReferenceDatasetId) {

frontend/src/hooks/useSegmentationWorkflow.ts

@@ -72,7 +72,7 @@ export function useSegmentationWorkflow({
         )
       }
     } catch (error) {
-      setSegmentationModelError(formatError(error, 'Failed to load segmentation models'))
+      setSegmentationModelError(formatError(error, 'De segmentatiemodellen konden niet worden geladen'))
     } finally {
       setLoadingSegmentationModels(false)
     }
@@ -90,7 +90,7 @@ export function useSegmentationWorkflow({
         setSelectedSegmentationRunId(response.items[0].id)
       }
     } catch (error) {
-      setSegmentationRunError(formatError(error, 'Failed to load segmentation runs'))
+      setSegmentationRunError(formatError(error, 'De segmentatieruns konden niet worden geladen'))
     }
   }
 
@@ -115,7 +115,7 @@ export function useSegmentationWorkflow({
       setSegmentationItems(segmentationsResponse.items)
       setSegmentationGeoJson(geoJsonResponse)
     } catch (error) {
-      setSegmentationRunError(formatError(error, 'Failed to load segmentation results'))
+      setSegmentationRunError(formatError(error, 'De segmentatieresultaten konden niet worden geladen'))
     } finally {
       setLoadingSegmentationResults(false)
     }
@@ -123,16 +123,16 @@ export function useSegmentationWorkflow({
 
   const runSegmentation = async () => {
     if (!selectedProjectId) {
-      setSegmentationRunError('Select a project first')
+      setSegmentationRunError('Kies eerst een werkruimte')
       return
     }
     const datasetId = selectedSegmentationDatasetId || rasterDatasets[0]?.id
     if (!datasetId) {
-      setSegmentationRunError('Select a raster dataset')
+      setSegmentationRunError('Kies eerst een rasterbron')
       return
     }
     if (!selectedSegmentationModel?.configured) {
-      setSegmentationRunError('Selected segmentation model is not configured')
+      setSegmentationRunError('Het gekozen segmentatiemodel is niet geconfigureerd')
       return
     }
     setSegmentationRunError(null)
@@ -165,11 +165,11 @@ export function useSegmentationWorkflow({
 
   const runSegmentationQa = async () => {
     if (!selectedSegmentationRunId) {
-      setSegmentationQaError('Select a segmentation run')
+      setSegmentationQaError('Kies eerst een segmentatierun')
       return
     }
     if (!segmentationReferenceDatasetId) {
-      setSegmentationQaError('Select a reference dataset')
+      setSegmentationQaError('Kies eerst een referentiebron')
       return
     }
     setSegmentationQaError(null)