@datagouv/components-next 1.0.2-dev.149 → 1.0.2-dev.150

package/dist/{vue3-xml-viewer.common-DFRPttwN.js → vue3-xml-viewer.common-9Hozz8ne.js}

@@ -1,4 +1,4 @@
-import { g as Ke } from "./main-BpmTmbJK.js";
+import { g as Ke } from "./main-CWzZZ7OE.js";
 import We from "vue";
 function Fe($, K) {
   for (var V = 0; V < K.length; V++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datagouv/components-next",
-  "version": "1.0.2-dev.149",
+  "version": "1.0.2-dev.150",
   "private": false,
   "type": "module",
   "engines": {

package/src/components/ResourceExplorer/ResourceExplorerViewer.vue

@@ -122,6 +122,11 @@
                 v-if="ogcWms"
                 :resource="resource"
               />
+              <PreviewUnavailable v-if="!hasPmtiles && !ogcWms && hasPmtilesError">
+                {{ t("La carte n'a pas pu être générée automatiquement pour ce fichier.") }}
+                <br>
+                <span class="text-gray-medium text-xs">{{ pmtilesError }}</span>
+              </PreviewUnavailable>
             </div>
             <div v-if="tab.key === 'data'">
               <JsonPreview
@@ -275,6 +280,8 @@ const { formatRelativeIfRecentDate } = useFormatDate()
 const {
   hasTabularData,
   hasPmtiles,
+  hasPmtilesError,
+  pmtilesError,
   hasDatafairPreview,
   hasOpenAPIPreview,
   ogcService,

package/src/composables/useHasTabularData.ts

@@ -1,4 +1,5 @@
 import { useComponentsConfig } from '../config'
+import { hasTabularParsingError } from '../functions/resources'
 import type { Resource } from '../types/resources'
 
 /**
@@ -20,7 +21,7 @@ export const useHasTabularData = () => {
     return (
       config.tabularApiUrl
       && resource.extras['analysis:parsing:parsing_table']
-      && !resource.extras['analysis:parsing:error']
+      && !hasTabularParsingError(resource)
       && !sourceUnreachable
       && (config.tabularAllowRemote || resource.filetype === 'file')
     )

package/src/composables/useResourceCapabilities.ts

@@ -2,7 +2,7 @@ import { computed, toValue, type MaybeRefOrGetter } from 'vue'
 import { useComponentsConfig } from '../config'
 import { useTranslation } from './useTranslation'
 import { useHasTabularData } from './useHasTabularData'
-import { detectOgcService } from '../functions/resources'
+import { detectOgcService, getParsingErrorMessage, getParsingErrorStep } from '../functions/resources'
 import { isOrganizationCertified } from '../functions/organizations'
 import type { Resource, WfsMetadata } from '../types/resources'
 import type { Dataset, DatasetV2 } from '../types/datasets'
@@ -49,6 +49,11 @@ export function useResourceCapabilities(
   const ogcService = computed(() => detectOgcService(toValue(resource)))
   const ogcWms = computed(() => ogcService.value === 'wms')
 
+  // The map is built from a pmtiles export; when that export fails we still want
+  // to show the Carte tab, but with the reason it could not be generated.
+  const hasPmtilesError = computed(() => getParsingErrorStep(toValue(resource)) === 'pmtiles_export')
+  const pmtilesError = computed(() => hasPmtilesError.value ? getParsingErrorMessage(toValue(resource)) : null)
+
   const generatedFormats = computed(() => {
     const r = toValue(resource)
     const formats = GENERATED_FORMATS
@@ -85,21 +90,27 @@ export function useResourceCapabilities(
     const r = toValue(resource)
     const options = []
 
-    if (hasTabularData.value) {
-      options.push({ key: 'data', label: t('Données') })
+    const dataTab = { key: 'data', label: hasTabularData.value ? t('Données') : t('Aperçu') }
+    const mapTab = { key: 'map', label: t('Carte') }
+    const hasMap = hasPmtiles.value || ogcWms.value
+
+    // The map is the most visual preview: when it is available, show it first.
+    // When its generation failed, keep the data preview first and surface the
+    // Carte tab (with its error) right after.
+    if (hasMap) {
+      options.push(mapTab, dataTab)
+    }
+    else if (hasPmtilesError.value) {
+      options.push(dataTab, mapTab)
     }
     else {
-      options.push({ key: 'data', label: t('Aperçu') })
+      options.push(dataTab)
     }
 
     if (hasTabularData.value) {
       options.push({ key: 'data-structure', label: t('Structure des données') })
     }
 
-    if (hasPmtiles.value || ogcWms.value) {
-      options.push({ key: 'map', label: t('Carte') })
-    }
-
     if (r.description) {
       options.push({ key: 'description', label: t('Description') })
     }
@@ -118,6 +129,8 @@ export function useResourceCapabilities(
     hasPreview,
     hasTabularData,
     hasPmtiles,
+    hasPmtilesError,
+    pmtilesError,
     hasDatafairPreview,
     hasOpenAPIPreview,
     ogcService,

package/src/functions/resources.ts

@@ -167,6 +167,40 @@ export function getResourceFilesize(resource: Resource): null | number {
   return null
 }
 
+// Parsing errors are stored as `<step>:<message>`, where `<step>` names the
+// analysis step that failed (e.g. `pmtiles_export`, `geojson_export`).
+
+/** The analysis step that failed, or null when there is no parsing error. */
+export function getParsingErrorStep(resource: Resource): string | null {
+  const error = resource.extras['analysis:parsing:error']
+  if (typeof error !== 'string' || !error) return null
+  const [step] = error.split(':', 1)
+  return step ?? null
+}
+
+/** The parsing error message without its `<step>:` prefix, or null when there is none. */
+export function getParsingErrorMessage(resource: Resource): string | null {
+  const error = resource.extras['analysis:parsing:error']
+  if (typeof error !== 'string' || !error) return null
+  const colon = error.indexOf(':')
+  return colon === -1 ? error : error.slice(colon + 1)
+}
+
+// Geo/format export steps run *after* the tabular table has been built, so a
+// failure here (e.g. a huge geometry timing out the pmtiles export) leaves the
+// tabular data fully usable and must not disable the tabular explorer.
+const NON_TABULAR_PARSING_ERROR_STEPS = ['pmtiles_export', 'geojson_export']
+
+/**
+ * Whether the resource's parsing error prevents reading its tabular data.
+ * Only errors from the tabular parsing itself are fatal; downstream geo/format
+ * export failures are not.
+ */
+export function hasTabularParsingError(resource: Resource): boolean {
+  const step = getParsingErrorStep(resource)
+  return step !== null && !NON_TABULAR_PARSING_ERROR_STEPS.includes(step)
+}
+
 type CorsStatus = 'allowed' | 'blocked' | 'unknown'
 
 export const getResourceCorsStatus = (resource: Resource): CorsStatus => {