@geode/opengeodeweb-front 10.36.0 → 10.37.0

package/app/components/Screenshot.vue

@@ -1,10 +1,12 @@
 <script setup lang="ts">
+import viewer_schemas, {
+  type ViewerTakeScreenshotParams,
+} from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 import ToolPanel from "@ogw_front/components/ToolPanel.vue";
 import fileDownload from "js-file-download";
 import { useClipboardItems } from "@vueuse/core";
 import { useFeedbackStore } from "@ogw_front/stores/feedback";
 import { useViewerStore } from "@ogw_front/stores/viewer";
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 const DEFAULT_PANEL_WIDTH = 260;
 
@@ -20,7 +22,7 @@ const { width = DEFAULT_PANEL_WIDTH, escapeFunction = undefined } = defineProps<
 const output_extensions =
   viewer_schemas.opengeodeweb_viewer.viewer.take_screenshot.properties.output_extension.enum;
 const filename = ref<string>("");
-const output_extension = ref<string>("png");
+const output_extension = ref<ViewerTakeScreenshotParams["output_extension"]>("png");
 const include_background = ref<boolean>(true);
 const screenshot_type = ref<string>("file");
 
@@ -42,8 +44,8 @@ async function takeScreenshot(): Promise<void> {
       params,
     },
     {
-      response_function: async (response: unknown) => {
-        const { blob } = response as { blob: BlobPart };
+      // `blob` is a wslink attachment: the viewer sends its key, the client receives the binary in its place
+      response_function: async ({ blob }) => {
         if (screenshot_type.value === "file") {
           fileDownload(blob, `${current_filename}.${output_extension.value}`);
           feedbackStore.add_success("Screenshot downloaded");

package/app/components/ViewToolbar.vue

@@ -1,4 +1,7 @@
 <script setup lang="ts">
+import schemas, {
+  type PickedFieldType,
+} from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 import ActionButton from "@ogw_front/components/ActionButton.vue";
 import CameraBookmarkIcon from "@ogw_front/assets/viewer_svgs/camera-bookmark.svg";
 import CameraManager from "@ogw_front/components/CameraManager.vue";
@@ -10,7 +13,6 @@ import ShrinkFilter from "@ogw_front/components/ShrinkFilter.vue";
 import ThresholdFilter from "@ogw_front/components/ThresholdFilter.vue";
 import ZScaling from "@ogw_front/components/ZScaling.vue";
 import { onKeyStroke } from "@vueuse/core";
-import schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
@@ -96,7 +98,7 @@ function toggleTool(toolRef: Ref<boolean>): void {
   toolRef.value = !toolRef.value;
 }
 
-function toggleHoverHighlight(fieldType: string): void {
+function toggleHoverHighlight(fieldType: PickedFieldType): void {
   const activate =
     !hybridViewerStore.is_hover_highlight ||
     hybridViewerStore.hover_highlight_field_type !== fieldType;

package/app/components/Viewer/EdgedCurve/SpecificEdgesOptions.vue

@@ -53,6 +53,9 @@ const coloring_style_key = computed<string>({
 const color = computed<RGBAColor | undefined>({
   get: () => dataStyleStore.meshEdgesColor(id.value) as RGBAColor | undefined,
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshEdgesColor(targetId, newValue),
     );
@@ -102,8 +105,8 @@ const vertex_attribute_color_map = computed<Map<string, RGBAColor>>({
     hybridViewerStore.remoteRender();
   },
 });
-const vertex_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () => dataStyleStore.meshEdgesVertexAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const vertex_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshEdgesVertexAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshEdgesVertexAttributeNoDataColor(targetId, newValue),
@@ -154,8 +157,8 @@ const edge_attribute_color_map = computed<Map<string, RGBAColor>>({
     hybridViewerStore.remoteRender();
   },
 });
-const edge_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () => dataStyleStore.meshEdgesEdgeAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const edge_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshEdgesEdgeAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshEdgesEdgeAttributeNoDataColor(targetId, newValue),

package/app/components/Viewer/Generic/Mesh/CellsOptions.vue

@@ -49,6 +49,9 @@ const coloring_style_key = computed<string>({
 const color = computed<RGBAColor | undefined>({
   get: () => dataStyleStore.meshCellsColor(id.value) as RGBAColor | undefined,
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshCellsColor(targetId, newValue),
     );
@@ -58,6 +61,9 @@ const color = computed<RGBAColor | undefined>({
 const textures = computed<Texture[] | undefined>({
   get: () => dataStyleStore.meshCellsTextures(id.value) as Texture[] | undefined,
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshCellsTextures(targetId, newValue),
     );
@@ -108,8 +114,8 @@ const vertex_attribute_color_map = computed<Map<string, RGBAColor>>({
     hybridViewerStore.remoteRender();
   },
 });
-const vertex_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () => dataStyleStore.meshCellsVertexAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const vertex_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshCellsVertexAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshCellsVertexAttributeNoDataColor(targetId, newValue),
@@ -160,8 +166,8 @@ const cell_attribute_color_map = computed<Map<string, RGBAColor>>({
     hybridViewerStore.remoteRender();
   },
 });
-const cell_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () => dataStyleStore.meshCellsCellAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const cell_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshCellsCellAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshCellsCellAttributeNoDataColor(targetId, newValue),

package/app/components/Viewer/Generic/Mesh/EdgesOptions.vue

@@ -54,6 +54,9 @@ const coloring_style_key = computed<string>({
 const color = computed<RGBAColor | undefined>({
   get: () => dataStyleStore.meshEdgesColor(id.value) as RGBAColor | undefined,
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshEdgesColor(targetId, newValue),
     );
@@ -103,8 +106,8 @@ const vertex_attribute_color_map = computed<Map<string, RGBAColor>>({
     hybridViewerStore.remoteRender();
   },
 });
-const vertex_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () => dataStyleStore.meshEdgesVertexAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const vertex_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshEdgesVertexAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshEdgesVertexAttributeNoDataColor(targetId, newValue),
@@ -155,8 +158,8 @@ const edge_attribute_color_map = computed<Map<string, RGBAColor>>({
     hybridViewerStore.remoteRender();
   },
 });
-const edge_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () => dataStyleStore.meshEdgesEdgeAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const edge_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshEdgesEdgeAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshEdgesEdgeAttributeNoDataColor(targetId, newValue),

package/app/components/Viewer/Generic/Mesh/PointsOptions.vue

@@ -54,6 +54,9 @@ const coloring_style_key = computed<string>({
 const color = computed<RGBAColor | undefined>({
   get: () => dataStyleStore.meshPointsColor(id.value) as RGBAColor | undefined,
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPointsColor(targetId, newValue),
     );
@@ -103,8 +106,8 @@ const vertex_attribute_color_map = computed<Map<string, RGBAColor>>({
     hybridViewerStore.remoteRender();
   },
 });
-const vertex_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () => dataStyleStore.meshPointsVertexAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const vertex_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshPointsVertexAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPointsVertexAttributeNoDataColor(targetId, newValue),

package/app/components/Viewer/Generic/Mesh/PolygonsOptions.vue

@@ -60,6 +60,9 @@ const coloring_style_key = computed<string>({
 const color = computed<RGBAColor | undefined>({
   get: () => dataStyleStore.meshPolygonsColor(id.value) as RGBAColor | undefined,
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPolygonsColor(targetId, newValue),
     );
@@ -69,6 +72,9 @@ const color = computed<RGBAColor | undefined>({
 const textures = computed<Texture[] | undefined>({
   get: () => dataStyleStore.meshPolygonsTextures(id.value) as Texture[] | undefined,
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPolygonsTextures(targetId, newValue),
     );
@@ -121,9 +127,8 @@ const vertex_attribute_color_map = computed<Map<string, RGBAColor>>({
     hybridViewerStore.remoteRender();
   },
 });
-const vertex_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.meshPolygonsVertexAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const vertex_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshPolygonsVertexAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPolygonsVertexAttributeNoDataColor(targetId, newValue),
@@ -176,9 +181,8 @@ const polygon_attribute_color_map = computed<Map<string, RGBAColor>>({
     hybridViewerStore.remoteRender();
   },
 });
-const polygon_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.meshPolygonsPolygonAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const polygon_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshPolygonsPolygonAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPolygonsPolygonAttributeNoDataColor(targetId, newValue),

package/app/components/Viewer/Generic/Mesh/PolyhedraOptions.vue

@@ -44,6 +44,9 @@ const coloring_style_key = computed<string>({
 const color = computed<RGBAColor | undefined>({
   get: () => dataStyleStore.meshPolyhedraColor(id.value) as RGBAColor | undefined,
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPolyhedraColor(targetId, newValue),
     );
@@ -95,9 +98,8 @@ const vertex_attribute_color_map = computed<Map<string, RGBAColor>>({
     hybridViewerStore.remoteRender();
   },
 });
-const vertex_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.meshPolyhedraVertexAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const vertex_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshPolyhedraVertexAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPolyhedraVertexAttributeNoDataColor(targetId, newValue),
@@ -152,9 +154,8 @@ const polyhedron_attribute_color_map = computed<Map<string, RGBAColor>>({
     hybridViewerStore.remoteRender();
   },
 });
-const polyhedron_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.meshPolyhedraPolyhedronAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const polyhedron_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshPolyhedraPolyhedronAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPolyhedraPolyhedronAttributeNoDataColor(targetId, newValue),

package/app/components/Viewer/Generic/Model/BlocksOptions.vue

@@ -44,7 +44,7 @@ const blocksVisibility = computed<boolean>({
 const blockVisibility = computed<boolean | undefined>({
   get: () => dataStyleStore.modelBlockVisibility(modelId, blockId) as boolean | undefined,
   set: async (newValue) => {
-    if (blockId === undefined) {
+    if (newValue === undefined || blockId === undefined) {
       return;
     }
     await dataStyleStore.setModelBlocksVisibility(modelId, [blockId], newValue);
@@ -154,11 +154,8 @@ const blocksVertexAttributeColorMap = computed<Map<string, RGBAColor> | undefine
   },
 });
 
-const blocksVertexAttributeNoDataColor = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.modelBlocksVertexAttributeNoDataColor(modelId, referenceBlockId.value) as
-      | RGBAColor
-      | undefined,
+const blocksVertexAttributeNoDataColor = computed<RGBAColor>({
+  get: () => dataStyleStore.modelBlocksVertexAttributeNoDataColor(modelId, referenceBlockId.value),
   set: async (newValue) => {
     await dataStyleStore.setModelBlocksVertexAttributeNoDataColor(
       modelId,
@@ -217,11 +214,9 @@ const blocksPolyhedronAttributeColorMap = computed<Map<string, RGBAColor> | unde
   },
 });
 
-const blocksPolyhedronAttributeNoDataColor = computed<RGBAColor | undefined>({
+const blocksPolyhedronAttributeNoDataColor = computed<RGBAColor>({
   get: () =>
-    dataStyleStore.modelBlocksPolyhedronAttributeNoDataColor(modelId, referenceBlockId.value) as
-      | RGBAColor
-      | undefined,
+    dataStyleStore.modelBlocksPolyhedronAttributeNoDataColor(modelId, referenceBlockId.value),
   set: async (newValue) => {
     await dataStyleStore.setModelBlocksPolyhedronAttributeNoDataColor(
       modelId,
@@ -278,9 +273,8 @@ const vertexAttributeColorMap = computed<Map<string, RGBAColor> | undefined>({
   },
 });
 
-const vertexAttributeNoDataColor = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.modelBlocksVertexAttributeNoDataColor(modelId, blockId) as RGBAColor | undefined,
+const vertexAttributeNoDataColor = computed<RGBAColor>({
+  get: () => dataStyleStore.modelBlocksVertexAttributeNoDataColor(modelId, blockId),
   set: async (newValue) => {
     if (blockId === undefined) {
       return;
@@ -340,11 +334,8 @@ const polyhedronAttributeColorMap = computed<Map<string, RGBAColor> | undefined>
   },
 });
 
-const polyhedronAttributeNoDataColor = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.modelBlocksPolyhedronAttributeNoDataColor(modelId, blockId) as
-      | RGBAColor
-      | undefined,
+const polyhedronAttributeNoDataColor = computed<RGBAColor>({
+  get: () => dataStyleStore.modelBlocksPolyhedronAttributeNoDataColor(modelId, blockId),
   set: async (newValue) => {
     if (blockId === undefined) {
       return;

package/app/components/Viewer/Generic/Model/CornersOptions.vue

@@ -44,7 +44,7 @@ const cornersVisibility = computed<boolean>({
 const cornerVisibility = computed<boolean | undefined>({
   get: () => dataStyleStore.modelCornerVisibility(modelId, cornerId) as boolean | undefined,
   set: async (newValue) => {
-    if (cornerId === undefined) {
+    if (newValue === undefined || cornerId === undefined) {
       return;
     }
     await dataStyleStore.setModelCornersVisibility(modelId, [cornerId], newValue);
@@ -156,11 +156,9 @@ const cornersVertexAttributeColorMap = computed<ColorMap | undefined>({
   },
 });
 
-const cornersVertexAttributeNoDataColor = computed<RGBAColor | undefined>({
+const cornersVertexAttributeNoDataColor = computed<RGBAColor>({
   get: () =>
-    dataStyleStore.modelCornersVertexAttributeNoDataColor(modelId, referenceCornerId.value) as
-      | RGBAColor
-      | undefined,
+    dataStyleStore.modelCornersVertexAttributeNoDataColor(modelId, referenceCornerId.value),
   set: async (newValue) => {
     await dataStyleStore.setModelCornersVertexAttributeNoDataColor(
       modelId,
@@ -217,11 +215,8 @@ const vertexAttributeColorMap = computed<ColorMap | undefined>({
   },
 });
 
-const vertexAttributeNoDataColor = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.modelCornersVertexAttributeNoDataColor(modelId, cornerId) as
-      | RGBAColor
-      | undefined,
+const vertexAttributeNoDataColor = computed<RGBAColor>({
+  get: () => dataStyleStore.modelCornersVertexAttributeNoDataColor(modelId, cornerId),
   set: async (newValue) => {
     if (cornerId === undefined) {
       return;

package/app/components/Viewer/Generic/Model/EdgesOptions.vue

@@ -23,6 +23,9 @@ const id = computed(() => (itemProps.meta_data.modelId as string | undefined) ||
 const visibility = computed({
   get: () => dataStyleStore.modelEdgesVisibility(id.value),
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setModelEdgesVisibility(targetId, newValue),
     );

package/app/components/Viewer/Generic/Model/LinesOptions.vue

@@ -44,7 +44,7 @@ const linesVisibility = computed<boolean>({
 const lineVisibility = computed<boolean | undefined>({
   get: () => dataStyleStore.modelLineVisibility(modelId, lineId) as boolean | undefined,
   set: async (newValue) => {
-    if (lineId === undefined) {
+    if (newValue === undefined || lineId === undefined) {
       return;
     }
     await dataStyleStore.setModelLinesVisibility(modelId, [lineId], newValue);
@@ -153,11 +153,8 @@ const linesVertexAttributeColorMap = computed<RGBAColorMap | undefined>({
   },
 });
 
-const linesVertexAttributeNoDataColor = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.modelLinesVertexAttributeNoDataColor(modelId, referenceLineId.value) as
-      | RGBAColor
-      | undefined,
+const linesVertexAttributeNoDataColor = computed<RGBAColor>({
+  get: () => dataStyleStore.modelLinesVertexAttributeNoDataColor(modelId, referenceLineId.value),
   set: async (newValue) => {
     await dataStyleStore.setModelLinesVertexAttributeNoDataColor(modelId, targetLineIds, newValue);
     hybridViewerStore.remoteRender();
@@ -203,11 +200,8 @@ const linesEdgeAttributeColorMap = computed<Map<string, RGBAColor> | undefined>(
   },
 });
 
-const linesEdgeAttributeNoDataColor = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.modelLinesEdgeAttributeNoDataColor(modelId, referenceLineId.value) as
-      | RGBAColor
-      | undefined,
+const linesEdgeAttributeNoDataColor = computed<RGBAColor>({
+  get: () => dataStyleStore.modelLinesEdgeAttributeNoDataColor(modelId, referenceLineId.value),
   set: async (newValue) => {
     await dataStyleStore.setModelLinesEdgeAttributeNoDataColor(modelId, targetLineIds, newValue);
     hybridViewerStore.remoteRender();
@@ -260,9 +254,8 @@ const vertexAttributeColorMap = computed<ColorMap | undefined>({
   },
 });
 
-const vertexAttributeNoDataColor = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.modelLinesVertexAttributeNoDataColor(modelId, lineId) as RGBAColor | undefined,
+const vertexAttributeNoDataColor = computed<RGBAColor>({
+  get: () => dataStyleStore.modelLinesVertexAttributeNoDataColor(modelId, lineId),
   set: async (newValue) => {
     if (lineId === undefined) {
       return;
@@ -317,9 +310,8 @@ const edgeAttributeColorMap = computed<Map<string, RGBAColor> | undefined>({
   },
 });
 
-const edgeAttributeNoDataColor = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.modelLinesEdgeAttributeNoDataColor(modelId, lineId) as RGBAColor | undefined,
+const edgeAttributeNoDataColor = computed<RGBAColor>({
+  get: () => dataStyleStore.modelLinesEdgeAttributeNoDataColor(modelId, lineId),
   set: async (newValue) => {
     if (lineId === undefined) {
       return;

package/app/components/Viewer/Generic/Model/SurfacesOptions.vue

@@ -160,11 +160,9 @@ const surfacesVertexAttributeColorMap = computed<Map<string, RGBAColor> | undefi
   },
 });
 
-const surfacesVertexAttributeNoDataColor = computed<RGBAColor | undefined>({
+const surfacesVertexAttributeNoDataColor = computed<RGBAColor>({
   get: () =>
-    dataStyleStore.modelSurfacesVertexAttributeNoDataColor(modelId, referenceSurfaceId.value) as
-      | RGBAColor
-      | undefined,
+    dataStyleStore.modelSurfacesVertexAttributeNoDataColor(modelId, referenceSurfaceId.value),
   set: async (newValue) => {
     await dataStyleStore.setModelSurfacesVertexAttributeNoDataColor(
       modelId,
@@ -224,11 +222,9 @@ const surfacesPolygonAttributeColorMap = computed<Map<string, RGBAColor> | undef
   },
 });
 
-const surfacesPolygonAttributeNoDataColor = computed<RGBAColor | undefined>({
+const surfacesPolygonAttributeNoDataColor = computed<RGBAColor>({
   get: () =>
-    dataStyleStore.modelSurfacesPolygonAttributeNoDataColor(modelId, referenceSurfaceId.value) as
-      | RGBAColor
-      | undefined,
+    dataStyleStore.modelSurfacesPolygonAttributeNoDataColor(modelId, referenceSurfaceId.value),
   set: async (newValue) => {
     await dataStyleStore.setModelSurfacesPolygonAttributeNoDataColor(
       modelId,
@@ -290,11 +286,8 @@ const vertexAttributeColorMap = computed<Map<string, RGBAColor> | undefined>({
   },
 });
 
-const vertexAttributeNoDataColor = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.modelSurfacesVertexAttributeNoDataColor(modelId, surfaceId) as
-      | RGBAColor
-      | undefined,
+const vertexAttributeNoDataColor = computed<RGBAColor>({
+  get: () => dataStyleStore.modelSurfacesVertexAttributeNoDataColor(modelId, surfaceId),
   set: async (newValue) => {
     if (surfaceId === undefined) {
       return;
@@ -354,11 +347,8 @@ const polygonAttributeColorMap = computed<Map<string, RGBAColor> | undefined>({
   },
 });
 
-const polygonAttributeNoDataColor = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.modelSurfacesPolygonAttributeNoDataColor(modelId, surfaceId) as
-      | RGBAColor
-      | undefined,
+const polygonAttributeNoDataColor = computed<RGBAColor>({
+  get: () => dataStyleStore.modelSurfacesPolygonAttributeNoDataColor(modelId, surfaceId),
   set: async (newValue) => {
     if (surfaceId === undefined) {
       return;

package/app/components/Viewer/ObjectTree/Views/ModelTree.vue

@@ -212,10 +212,6 @@ function getLeafViewerIds(item: CollectionTreeItem): number[] {
   const actualItem = item.raw || item;
   return extractIds(actualItem);
 }
-
-function getLeafViewerIdsForFocus(item: CollectionTreeItem): string[] {
-  return getLeafViewerIds(item) as unknown as string[];
-}
 </script>
 
 <template>
@@ -272,7 +268,7 @@ function getLeafViewerIdsForFocus(item: CollectionTreeItem): string[] {
           @click.stop="
             hybridViewerStore.focusCameraOnObject(
               id,
-              getLeafViewerIdsForFocus(item as unknown as CollectionTreeItem),
+              getLeafViewerIds(item as unknown as CollectionTreeItem),
             )
           "
         />

package/app/components/Viewer/PointSet/SpecificPointsOptions.vue

@@ -26,6 +26,9 @@ const id = toRef(() => itemProps.id);
 const visibility = computed({
   get: () => dataStyleStore.meshPointsVisibility(id.value),
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPointsVisibility(targetId, newValue),
     );
@@ -35,6 +38,9 @@ const visibility = computed({
 const size = computed({
   get: () => dataStyleStore.meshPointsSize(id.value),
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPointsSize(targetId, newValue),
     );
@@ -53,6 +59,9 @@ const coloring_style_key = computed({
 const color = computed<RGBAColor | undefined>({
   get: () => dataStyleStore.meshPointsColor(id.value) as RGBAColor | undefined,
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPointsColor(targetId, newValue),
     );
@@ -102,8 +111,8 @@ const vertex_attribute_color_map = computed({
     hybridViewerStore.remoteRender();
   },
 });
-const vertex_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () => dataStyleStore.meshPointsVertexAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const vertex_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshPointsVertexAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPointsVertexAttributeNoDataColor(targetId, newValue),

package/app/components/Viewer/Solid/SpecificPolyhedraOptions.vue

@@ -44,6 +44,9 @@ const coloring_style_key = computed<string>({
 const color = computed<RGBAColor | undefined>({
   get: () => dataStyleStore.meshPolyhedraColor(id.value) as RGBAColor | undefined,
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPolyhedraColor(targetId, newValue),
     );
@@ -95,9 +98,8 @@ const vertex_attribute_color_map = computed<Map<string, RGBAColor> | undefined>(
     hybridViewerStore.remoteRender();
   },
 });
-const vertex_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.meshPolyhedraVertexAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const vertex_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshPolyhedraVertexAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPolyhedraVertexAttributeNoDataColor(targetId, newValue),
@@ -152,9 +154,8 @@ const polyhedron_attribute_color_map = computed<Map<string, RGBAColor> | undefin
     hybridViewerStore.remoteRender();
   },
 });
-const polyhedron_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.meshPolyhedraPolyhedronAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const polyhedron_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshPolyhedraPolyhedronAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPolyhedraPolyhedronAttributeNoDataColor(targetId, newValue),

package/app/components/Viewer/Surface/PolygonsOptions.vue

@@ -49,6 +49,9 @@ const coloring_style_key = computed<string>({
 const color = computed<RGBAColor | undefined>({
   get: () => dataStyleStore.meshPolygonsColor(id.value) as RGBAColor | undefined,
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPolygonsColor(targetId, newValue),
     );
@@ -58,6 +61,9 @@ const color = computed<RGBAColor | undefined>({
 const textures = computed<Texture[] | undefined>({
   get: () => dataStyleStore.meshPolygonsTextures(id.value) as Texture[] | undefined,
   set: async (newValue) => {
+    if (newValue === undefined) {
+      return;
+    }
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPolygonsTextures(targetId, newValue),
     );
@@ -109,9 +115,8 @@ const vertex_attribute_color_map = computed<Map<string, RGBAColor> | undefined>(
     hybridViewerStore.remoteRender();
   },
 });
-const vertex_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.meshPolygonsVertexAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const vertex_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshPolygonsVertexAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPolygonsVertexAttributeNoDataColor(targetId, newValue),
@@ -164,9 +169,8 @@ const polygon_attribute_color_map = computed<Map<string, RGBAColor> | undefined>
     hybridViewerStore.remoteRender();
   },
 });
-const polygon_attribute_no_data_color = computed<RGBAColor | undefined>({
-  get: () =>
-    dataStyleStore.meshPolygonsPolygonAttributeNoDataColor(id.value) as RGBAColor | undefined,
+const polygon_attribute_no_data_color = computed<RGBAColor>({
+  get: () => dataStyleStore.meshPolygonsPolygonAttributeNoDataColor(id.value),
   set: async (newValue) => {
     await applyBatchStyle(id.value, (targetId: string) =>
       dataStyleStore.setMeshPolygonsPolygonAttributeNoDataColor(targetId, newValue),

package/app/composables/hover_highlight.ts

@@ -1,12 +1,13 @@
-import type { JsonRpcSchema } from "@ogw_shared/utils/types";
+import type { ParamsOf } from "@ogw_shared/utils/types";
 import { consola } from "consola";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useViewerStore } from "@ogw_front/stores/viewer";
-import vtk_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
+import vtk_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 
 const HOVER_DELAY = 200;
 
 type HighlightType = "mesh" | "model";
+type HighlightSchema = (typeof vtk_schemas)["opengeodeweb_viewer"][HighlightType]["highlight"];
 type BlockIdsProvider = readonly number[] | (() => readonly number[] | Promise<readonly number[]>);
 
 export function useHoverhighlight(): {
@@ -88,8 +89,8 @@ export function useHoverhighlight(): {
     type: HighlightType,
     id: string,
     request: {
-      schema: JsonRpcSchema;
-      params?: Record<string, unknown>;
+      schema: HighlightSchema;
+      params?: ParamsOf<HighlightSchema>;
       timeout?: number;
     },
   ): Promise<void> {