@geode/opengeodeweb-front 10.40.0 → 10.41.0-rc.1

package/app/components/Viewer/Options/AttributeSelector.vue

@@ -4,9 +4,13 @@ import {
   type RangesPerData,
   useBatchGroup,
 } from "@ogw_front/composables/batch_style";
+import {
+  type AttributeRangeInfo,
+  type AttributeSchemas,
+  fetchAttributeRange,
+} from "@ogw_front/utils/attribute_range";
 import { getAttributeRange, intersectAttributes } from "@ogw_front/utils/attributes";
 import { DEFAULT_NO_DATA_COLOR } from "@ogw_front/utils/default_styles/constants";
-import type { JsonRpcSchema } from "@ogw_shared/utils/types.js";
 import ViewerOptionsAttributeColorBar from "@ogw_front/components/Viewer/Options/AttributeColorBar.vue";
 import ViewerOptionsColorPicker from "@ogw_front/components/Viewer/Options/ColorPicker.vue";
 import ViewerOptionsTimeStepSlider from "@ogw_front/components/Viewer/Options/TimeStepSlider.vue";
@@ -27,10 +31,10 @@ const attributeTimeStep = defineModel<number>("attributeTimeStep");
 interface Props {
   id: string;
   componentIds?: string[];
-  schema: JsonRpcSchema;
+  schemas: AttributeSchemas;
 }
 
-const { id, componentIds = undefined, schema } = defineProps<Props>();
+const { id, componentIds = undefined, schemas } = defineProps<Props>();
 
 interface Emits {
   "update:attributeColorMap": [colorMap: string];
@@ -43,13 +47,15 @@ const emit = defineEmits<Emits>();
 interface AttributeInfo {
   attribute_name: string;
   nb_items: number;
-  no_data?: boolean;
   time_steps?: number[];
   [key: string]: unknown;
 }
 
 const attributes = ref<AttributeInfo[]>([]);
 let attributesPerTarget = new Map<string, AttributeInfo[]>();
+const rangesPerTarget = ref(new Map<string, AttributeRangeInfo>());
+let rangesName: string | undefined = undefined;
+let rangesLoading: Promise<void> = Promise.resolve();
 
 const groupTargetIds = useBatchGroup(() => id);
 
@@ -57,6 +63,9 @@ const currentAttribute = computed<AttributeInfo | undefined>(() =>
   attributes.value.find((attr) => attr.attribute_name === attributeName.value),
 );
 const timeSteps = computed<number[]>(() => currentAttribute.value?.time_steps ?? []);
+const noData = computed<boolean>(() =>
+  [...rangesPerTarget.value.values()].some((range) => range.no_data),
+);
 
 let committedSeries: string | undefined = undefined;
 
@@ -72,7 +81,10 @@ function commitSeriesTimeStep(): void {
   committedSeries = name;
   const current = attributeTimeStep.value;
   const valid = current !== undefined && current >= 0 && current < timeSteps.value.length;
-  emit("update:attributeTimeStep", valid ? current : 0);
+  // A valid step is already stored and applied with the series: emitting it again re-applies the attribute
+  if (!valid) {
+    emit("update:attributeTimeStep", 0);
+  }
 }
 
 const cssNoDataColor = computed<string>(() => {
@@ -118,68 +130,105 @@ const componentItems = computed<{ title: string; value: number }[]>(() => {
   }));
 });
 
-function resetRange(): void {
-  if (currentAttribute.value) {
-    const comp = attributeItem.value ?? 0;
-    // GetAttributeRange's parameter type (AttributeRangeSource) isn't exported;
-    // AttributeInfo's index signature covers its optional min/max fields at
-    // Runtime (they come from the same backend attribute response shape).
-    const { min, max } = getAttributeRange(
-      currentAttribute.value as unknown as Parameters<typeof getAttributeRange>[0],
-      comp,
-    );
-    attributeRange.value = [min, max];
+function hasSelectedComponent(components: unknown): boolean {
+  return Array.isArray(components) && components.length > 0;
+}
+
+function requestParams(): { id: string; component_ids?: string[] } | undefined {
+  const schemaProperties = schemas.names.properties as Record<string, unknown> | undefined;
+  if (schemaProperties?.component_ids === undefined) {
+    return { id };
   }
+  return hasSelectedComponent(componentIds) ? { id, component_ids: componentIds } : undefined;
 }
 
-function hasSelectedComponent(components: unknown): boolean {
-  return Array.isArray(components) && components.length > 0;
+// Ranges are computed by the back for the selected attribute only, as scanning every step of every series is slow
+async function requestRanges(name: string): Promise<void> {
+  const targets: [string, { id: string; component_ids?: string[] } | undefined][] =
+    groupTargetIds.value
+      ? [...attributesPerTarget]
+          .filter(([, targetAttributes]) =>
+            targetAttributes.some((attribute) => attribute.attribute_name === name),
+          )
+          .map(([targetId]) => [targetId, { id: targetId }])
+      : [[id, requestParams()]];
+  const entries = await Promise.all(
+    targets.map(async ([targetId, params]): Promise<[string, AttributeRangeInfo | undefined]> => [
+      targetId,
+      params ? await fetchAttributeRange(schemas.range, params, name) : undefined,
+    ]),
+  );
+  if (rangesName !== name) {
+    return;
+  }
+  rangesPerTarget.value = new Map(
+    entries.filter((entry): entry is [string, AttributeRangeInfo] => entry[1] !== undefined),
+  );
+}
+
+async function loadRanges(name: string): Promise<void> {
+  if (name !== rangesName) {
+    rangesName = name;
+    rangesPerTarget.value = new Map();
+    rangesLoading = requestRanges(name);
+  }
+  await rangesLoading;
+}
+
+function applyRange(): void {
+  const { min, max } = getAttributeRange(rangesPerTarget.value.get(id), attributeItem.value ?? 0);
+  attributeRange.value = [min, max];
+}
+
+async function resetRange(): Promise<void> {
+  if (currentAttribute.value) {
+    await loadRanges(currentAttribute.value.attribute_name);
+    applyRange();
+  }
 }
 
 async function getGroupAttributes(targetIds: string[]): Promise<void> {
-  const responses = await requestForTargets<{ attributes: AttributeInfo[] }>(schema, targetIds, {
-    attributes: [],
-  });
+  const responses = await requestForTargets<{ attributes: AttributeInfo[] }>(
+    schemas.names,
+    targetIds,
+    {
+      attributes: [],
+    },
+  );
   attributesPerTarget = new Map(
     responses.map(([targetId, response]) => [targetId, response.attributes]),
   );
   attributes.value = intersectAttributes([...attributesPerTarget.values()]);
 }
 
-function initGroupAttribute(name: string, item: number): void {
+async function initGroupAttribute(name: string, item: number): Promise<void> {
+  await loadRanges(name);
+  if (attributeName.value !== name) {
+    return;
+  }
   const ranges = new Map<string, AttributeRange>();
-  for (const [targetId, targetAttributes] of attributesPerTarget) {
-    const attribute = targetAttributes.find((candidate) => candidate.attribute_name === name);
-    if (attribute) {
-      const { min, max } = getAttributeRange(
-        attribute as unknown as Parameters<typeof getAttributeRange>[0],
-        item,
-      );
-      ranges.set(targetId, [min, max]);
-    }
+  for (const [targetId, range] of rangesPerTarget.value) {
+    const { min, max } = getAttributeRange(range, item);
+    ranges.set(targetId, [min, max]);
   }
   emit("update:attributeColorMap", attributeColorMap.value ?? "batlow");
   emit("ranges_per_data", ranges);
 }
 
 async function getAttributes(): Promise<void> {
+  rangesName = undefined;
+  rangesPerTarget.value = new Map();
   if (groupTargetIds.value) {
     await getGroupAttributes(groupTargetIds.value);
     return;
   }
-  const schemaProperties = schema.properties as Record<string, unknown> | undefined;
-  const requiresComponent = schemaProperties?.component_ids !== undefined;
-  if (requiresComponent && !hasSelectedComponent(componentIds)) {
+  const params = requestParams();
+  if (!params) {
     return;
   }
 
-  const params: { id: string; component_ids?: unknown } = { id };
-  if (requiresComponent) {
-    params.component_ids = componentIds;
-  }
-
   await backStore.request(
-    { schema, params },
+    { schema: schemas.names, params },
     {
       response_function: (response: unknown) => {
         attributes.value = (response as { attributes: AttributeInfo[] }).attributes;
@@ -193,19 +242,19 @@ onMounted(async () => {
 });
 
 watch(
-  () => [id, componentIds, schema],
+  [(): string => id, (): string[] | undefined => componentIds, (): AttributeSchemas => schemas],
   async () => {
     await getAttributes();
   },
 );
 
-watch([attributeName, attributeItem], ([name, item]) => {
+watch([attributeName, attributeItem], async ([name, item]) => {
   if (groupTargetIds.value && name !== undefined) {
-    initGroupAttribute(name, item ?? 0);
+    await initGroupAttribute(name, item ?? 0);
   }
 });
 
-watch([attributeName, attributeItem, currentAttribute], () => {
+watch([attributeName, attributeItem, currentAttribute], async () => {
   commitSeriesTimeStep();
   if (groupTargetIds.value) {
     return;
@@ -216,8 +265,13 @@ watch([attributeName, attributeItem, currentAttribute], () => {
   if (attributeNoDataColor.value === undefined) {
     attributeNoDataColor.value = DEFAULT_NO_DATA_COLOR;
   }
-  if (attributeRange.value[0] === undefined) {
-    resetRange();
+  const name = currentAttribute.value?.attribute_name;
+  if (name === undefined) {
+    return;
+  }
+  await loadRanges(name);
+  if (name === currentAttribute.value?.attribute_name && attributeRange.value[0] === undefined) {
+    applyRange();
   }
 });
 </script>
@@ -247,7 +301,7 @@ watch([attributeName, attributeItem, currentAttribute], () => {
   />
   <ViewerOptionsTimeStepSlider v-model="attributeTimeStep" :time-steps="timeSteps" />
   <div
-    v-if="currentAttribute && currentAttribute.no_data"
+    v-if="currentAttribute && noData"
     class="text-caption text-high-emphasis mt-1 d-flex align-center ga-1"
     data-testid="noDataInfo"
   >

package/app/components/Viewer/Options/ColoringTypeSelector.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import type { JsonRpcSchema } from "@ogw_shared/utils/types.js";
+import type { AttributeSchemas } from "@ogw_front/utils/attribute_range";
 import type { RGBAColor } from "@ogw_front/utils/default_styles/constants";
 import type { RangesPerData } from "@ogw_front/composables/batch_style";
 import ViewerOptionsAttributeSelector from "@ogw_front/components/Viewer/Options/AttributeSelector.vue";
@@ -18,11 +18,11 @@ interface CapabilityConfig {
 }
 
 interface Schemas {
-  vertex?: JsonRpcSchema;
-  edge?: JsonRpcSchema;
-  cell?: JsonRpcSchema;
-  polygon?: JsonRpcSchema;
-  polyhedron?: JsonRpcSchema;
+  vertex?: AttributeSchemas;
+  edge?: AttributeSchemas;
+  cell?: AttributeSchemas;
+  polygon?: AttributeSchemas;
+  polyhedron?: AttributeSchemas;
 }
 
 const coloring_style_key = defineModel<string>("coloring_style_key");
@@ -95,12 +95,27 @@ const {
   allowRandom = false,
 } = defineProps<Props>();
 
-const vertexSchema = schemas.vertex || back_schemas.opengeodeweb_back.vertex_attribute_names;
-const edgeSchema = schemas.edge || back_schemas.opengeodeweb_back.edge_attribute_names;
-const cellSchema = schemas.cell || back_schemas.opengeodeweb_back.cell_attribute_names;
-const polygonSchema = schemas.polygon || back_schemas.opengeodeweb_back.polygon_attribute_names;
-const polyhedronSchema =
-  schemas.polyhedron || back_schemas.opengeodeweb_back.polyhedron_attribute_names;
+const backSchemas = back_schemas.opengeodeweb_back;
+const vertexSchemas = schemas.vertex ?? {
+  names: backSchemas.vertex_attribute_names,
+  range: backSchemas.vertex_attribute_range,
+};
+const edgeSchemas = schemas.edge ?? {
+  names: backSchemas.edge_attribute_names,
+  range: backSchemas.edge_attribute_range,
+};
+const cellSchemas = schemas.cell ?? {
+  names: backSchemas.cell_attribute_names,
+  range: backSchemas.cell_attribute_range,
+};
+const polygonSchemas = schemas.polygon ?? {
+  names: backSchemas.polygon_attribute_names,
+  range: backSchemas.polygon_attribute_range,
+};
+const polyhedronSchemas = schemas.polyhedron ?? {
+  names: backSchemas.polyhedron_attribute_names,
+  range: backSchemas.polyhedron_attribute_range,
+};
 
 function isAvailable(key: string): boolean {
   if (capabilities[key] && capabilities[key].available === false) {
@@ -266,7 +281,7 @@ watch(
           @ranges_per_data="emit('vertex_attribute_ranges_per_data', $event)"
           :id="id"
           :componentIds="componentIds"
-          :schema="vertexSchema"
+          :schemas="vertexSchemas"
         />
       </template>
       <template v-if="active_key === edge_dict['value'] && hasColorMap('edge')">
@@ -280,7 +295,7 @@ watch(
           @ranges_per_data="emit('edge_attribute_ranges_per_data', $event)"
           :id="id"
           :componentIds="componentIds"
-          :schema="edgeSchema"
+          :schemas="edgeSchemas"
         />
       </template>
       <template v-if="active_key === cell_dict['value'] && hasColorMap('cell')">
@@ -294,7 +309,7 @@ watch(
           @ranges_per_data="emit('cell_attribute_ranges_per_data', $event)"
           :id="id"
           :componentIds="componentIds"
-          :schema="cellSchema"
+          :schemas="cellSchemas"
         />
       </template>
       <template v-if="active_key === polygon_dict['value'] && hasColorMap('polygon')">
@@ -308,7 +323,7 @@ watch(
           @ranges_per_data="emit('polygon_attribute_ranges_per_data', $event)"
           :id="id"
           :componentIds="componentIds"
-          :schema="polygonSchema"
+          :schemas="polygonSchemas"
         />
       </template>
       <template v-if="active_key === polyhedron_dict['value'] && hasColorMap('polyhedron')">
@@ -322,7 +337,7 @@ watch(
           @ranges_per_data="emit('polyhedron_attribute_ranges_per_data', $event)"
           :id="id"
           :componentIds="componentIds"
-          :schema="polyhedronSchema"
+          :schemas="polyhedronSchemas"
         />
       </template>
     </v-col>

package/app/components/csv-preview/CsvSettings.vue

@@ -26,7 +26,7 @@ const emit = defineEmits<Emits>();
 const separators = [
   { title: "Comma (,)", value: "," },
   { title: "Semicolon (;)", value: ";" },
-  { title: "Tab (\\t)", value: "\t" },
+  { title: String.raw`Tab (\t)`, value: "\t" },
   { title: "Space ( )", value: " " },
   { title: "Pipe (|)", value: "|" },
   { title: "Custom", value: "custom" },

package/app/composables/global_attribute_style.ts

@@ -1,5 +1,6 @@
 import type { JsonRpcSchema } from "@ogw_shared/utils/types";
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
+import { fetchAttributeRange } from "@ogw_front/utils/attribute_range";
 import { getAttributeRange } from "@ogw_front/utils/attributes";
 import { useBackStore } from "@ogw_front/stores/back";
 import { useDataStyleStore } from "@ogw_front/stores/data_style";
@@ -35,10 +36,6 @@ interface AttributeStyleComponent {
 interface AttributeResponse {
   readonly attributes?: readonly {
     readonly attribute_name?: string;
-    readonly min_values?: readonly number[];
-    readonly max_values?: readonly number[];
-    readonly min_value?: number;
-    readonly max_value?: number;
     readonly time_steps?: readonly number[];
   }[];
 }
@@ -259,39 +256,29 @@ export function useGlobalAttributeStyle(dataIdRef: Ref<string | undefined>): {
         continue;
       }
 
-      const schemaName = `${activeColoring}_attribute_names`;
-      const backSchemas = back_schemas.opengeodeweb_back as Record<string, unknown>;
-      const schema = backSchemas[schemaName];
-      if (schema === undefined || !isJsonRpcSchema(schema)) {
+      const rangeSchema = (back_schemas.opengeodeweb_back as Record<string, unknown>)[
+        `${activeColoring}_attribute_range`
+      ];
+      if (!isJsonRpcSchema(rangeSchema)) {
         continue;
       }
 
       requestPromises.push(
-        backStore.request(
-          {
-            schema,
-            params: { id: targetId },
-          },
-          {
-            response_function: async (response: unknown): Promise<void> => {
-              if (!isAttributeResponse(response)) {
-                return;
-              }
-              const attributes = response.attributes ?? [];
-              const currentAttribute = attributes.find((attr) => attr.attribute_name === attrName);
-              if (currentAttribute) {
-                const { min, max } = getAttributeRange(currentAttribute, attrItem);
-
-                const setterName = `set${setterKey}${attributeType}Range`;
-                const setter = getDynamicStoreMethod(dataStyleStore, setterName);
-                if (setter) {
-                  setter(targetId, min, max);
-                  await hybridViewerStore.remoteRender();
-                }
-              }
-            },
-          },
-        ),
+        (async (): Promise<void> => {
+          const range = await fetchAttributeRange(rangeSchema, { id: targetId }, attrName);
+          if (!range) {
+            return;
+          }
+          const { min, max } = getAttributeRange(range, attrItem);
+          const setter = getDynamicStoreMethod(
+            dataStyleStore,
+            `set${setterKey}${attributeType}Range`,
+          );
+          if (setter) {
+            setter(targetId, min, max);
+            await hybridViewerStore.remoteRender();
+          }
+        })(),
       );
     }
 

package/app/utils/attribute_range.ts

@@ -0,0 +1,56 @@
+import type { JsonRpcSchema } from "@ogw_shared/utils/types.js";
+import { useBackStore } from "@ogw_front/stores/back";
+
+interface AttributeRangeInfo {
+  min_values: number[];
+  max_values: number[];
+  no_data: boolean;
+}
+
+// The *_attribute_names route listing the attributes, and its *_attribute_range route
+interface AttributeSchemas {
+  names: JsonRpcSchema;
+  range: JsonRpcSchema;
+}
+
+interface AttributeRangeTarget {
+  id: string;
+  component_ids?: string[];
+}
+
+// A data never changes once imported: selectors showing the same attribute share one request
+const rangeRequests = new Map<string, Promise<AttributeRangeInfo | undefined>>();
+
+async function requestAttributeRange(
+  rangeSchema: JsonRpcSchema,
+  params: Record<string, unknown>,
+  key: string,
+): Promise<AttributeRangeInfo | undefined> {
+  const backStore = useBackStore();
+  try {
+    const range = await backStore.request({ schema: rangeSchema, params });
+    // oxlint-disable-next-line no-unsafe-type-assertion -- every *_attribute_range schema shares this response.
+    return range as AttributeRangeInfo;
+  } catch {
+    rangeRequests.delete(key);
+    return undefined;
+  }
+}
+
+async function fetchAttributeRange(
+  rangeSchema: JsonRpcSchema,
+  target: AttributeRangeTarget,
+  attributeName: string,
+): Promise<AttributeRangeInfo | undefined> {
+  const params = { ...target, attribute_name: attributeName };
+  const key = JSON.stringify([rangeSchema.$id, params]);
+  let request = rangeRequests.get(key);
+  if (request === undefined) {
+    request = requestAttributeRange(rangeSchema, params, key);
+    rangeRequests.set(key, request);
+  }
+  const range = await request;
+  return range;
+}
+
+export { type AttributeRangeInfo, type AttributeSchemas, fetchAttributeRange };

package/app/utils/import_workflow.ts

@@ -96,18 +96,26 @@ async function importWorkflow(files: readonly FileToImport[]): Promise<string[]>
   }
 
   const results: string[] = [];
+  const errors: unknown[] = [];
   async function processChunk(chunkIndex: number): Promise<void> {
     if (chunkIndex >= chunks.length) {
       return;
     }
     const chunk = chunks[chunkIndex] ?? [];
-    const chunk_results = await Promise.all(
+    // A failing file does not prevent the other files from being imported
+    const chunk_results = await Promise.allSettled(
       chunk.map(async ({ filename, geode_object_type }) => {
         const id = await importFile(filename, geode_object_type);
         return id;
       }),
     );
-    results.push(...chunk_results);
+    for (const result of chunk_results) {
+      if (result.status === "fulfilled") {
+        results.push(result.value);
+      } else {
+        errors.push(result.reason);
+      }
+    }
     await processChunk(chunkIndex + 1);
   }
   await processChunk(0);
@@ -116,6 +124,9 @@ async function importWorkflow(files: readonly FileToImport[]): Promise<string[]>
     hybridViewerStore.resetCamera();
   }
   await hybridViewerStore.remoteRender();
+  if (errors.length > 0) {
+    throw new AggregateError(errors, `${errors.length} file(s) could not be imported`);
+  }
   return results;
 }