@geode/opengeodeweb-front 10.2.1 → 10.3.0

package/internal/stores/data_style/mesh/polyhedra/vertex.js

@@ -0,0 +1,153 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap"
+import { useMeshPolyhedraCommonStyle } from "./common"
+
+// Local constants
+const meshPolyhedraVertexAttributeSchemas =
+  viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.attribute.vertex
+
+export function useMeshPolyhedraVertexAttributeStyle() {
+  const viewerStore = useViewerStore()
+  const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle()
+
+  function meshPolyhedraVertexAttribute(id) {
+    return meshPolyhedraCommonStyle.meshPolyhedraColoring(id).vertex
+  }
+
+  async function updateMeshPolyhedraVertexAttribute(id) {
+    const name = meshPolyhedraVertexAttributeName(id)
+    const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name)
+    await meshPolyhedraVertexAttributeRange(
+      id,
+      storedConfig.minimum,
+      storedConfig.maximum,
+    )
+    await meshPolyhedraVertexAttributeColorMap(id, storedConfig.colorMap)
+  }
+
+  function meshPolyhedraVertexAttributeStoredConfig(id, name) {
+    const storedConfigs = meshPolyhedraVertexAttribute(id).storedConfigs
+    if (name in storedConfigs) {
+      return storedConfigs[name]
+    }
+    return setMeshPolyhedraVertexAttributeStoredConfig(id, name, {
+      minimum: 0,
+      maximum: 1,
+      colorMap: "Cool to Warm",
+    })
+  }
+
+  function setMeshPolyhedraVertexAttributeStoredConfig(
+    id,
+    name,
+    { minimum, maximum, colorMap },
+  ) {
+    const storedConfigs = meshPolyhedraVertexAttribute(id).storedConfigs
+    storedConfigs[name] = { minimum, maximum, colorMap }
+    return storedConfigs[name]
+  }
+
+  function meshPolyhedraVertexAttributeName(id) {
+    console.log(
+      meshPolyhedraVertexAttributeName.name,
+      { id },
+      meshPolyhedraVertexAttribute(id),
+    )
+    return meshPolyhedraVertexAttribute(id).name
+  }
+  function setMeshPolyhedraVertexAttributeName(id, name) {
+    console.log(setMeshPolyhedraVertexAttributeName.name, { id, name })
+    return viewerStore.request(
+      meshPolyhedraVertexAttributeSchemas.name,
+      { id, name },
+      {
+        response_function: async () => {
+          meshPolyhedraVertexAttribute(id).name = name
+          const { minimum, maximum, colorMap } =
+            meshPolyhedraVertexAttributeStoredConfig(id, name)
+          await setMeshPolyhedraVertexAttributeRange(id, minimum, maximum)
+          await setMeshPolyhedraVertexAttributeColorMap(id, colorMap)
+          console.log(
+            setMeshPolyhedraVertexAttributeName.name,
+            { id },
+            meshPolyhedraVertexAttributeName(id),
+          )
+        },
+      },
+    )
+  }
+
+  function meshPolyhedraVertexAttributeRange(id) {
+    const name = meshPolyhedraVertexAttributeName(id)
+    const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name)
+    const { minimum, maximum } = storedConfig
+    return [minimum, maximum]
+  }
+  function setMeshPolyhedraVertexAttributeRange(id, minimum, maximum) {
+    const name = meshPolyhedraVertexAttributeName(id)
+    const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name)
+    return viewerStore.request(
+      meshPolyhedraVertexAttributeSchemas.scalar_range,
+      { id, minimum, maximum },
+      {
+        response_function: () => {
+          storedConfig.minimum = minimum
+          storedConfig.maximum = maximum
+          console.log(
+            setMeshPolyhedraVertexAttributeRange.name,
+            { id },
+            meshPolyhedraVertexAttributeRange(id),
+          )
+        },
+      },
+    )
+  }
+
+  function meshPolyhedraVertexAttributeColorMap(id) {
+    const name = meshPolyhedraVertexAttributeName(id)
+    const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name)
+    const { colorMap } = storedConfig
+    return colorMap
+  }
+  function setMeshPolyhedraVertexAttributeColorMap(id, colorMap) {
+    const name = meshPolyhedraVertexAttributeName(id)
+    const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name)
+    const points = getRGBPointsFromPreset(colorMap)
+    const { minimum, maximum } = storedConfig
+
+    console.log(setMeshPolyhedraVertexAttributeColorMap.name, {
+      id,
+      minimum,
+      maximum,
+      colorMap,
+    })
+    return viewerStore.request(
+      meshPolyhedraVertexAttributeSchemas.color_map,
+      { id, points, minimum, maximum },
+      {
+        response_function: () => {
+          storedConfig.colorMap = colorMap
+          console.log(
+            setMeshPolyhedraVertexAttributeColorMap.name,
+            { id },
+            meshPolyhedraVertexAttributeColorMap(id),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    meshPolyhedraVertexAttributeName,
+    meshPolyhedraVertexAttributeRange,
+    meshPolyhedraVertexAttributeColorMap,
+    setMeshPolyhedraVertexAttributeName,
+    setMeshPolyhedraVertexAttributeRange,
+    setMeshPolyhedraVertexAttributeColorMap,
+    updateMeshPolyhedraVertexAttribute,
+  }
+}

package/internal/stores/data_style/mesh/polyhedra/visibility.js

@@ -0,0 +1,41 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshPolyhedraCommonStyle } from "./common"
+
+// Local constants
+const meshPolyhedraVisibilitySchema =
+  viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.visibility
+
+export function useMeshPolyhedraVisibilityStyle() {
+  const viewerStore = useViewerStore()
+  const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle()
+
+  function meshPolyhedraVisibility(id) {
+    return meshPolyhedraCommonStyle.meshPolyhedraStyle(id).visibility
+  }
+  function setMeshPolyhedraVisibility(id, visibility) {
+    return viewerStore.request(
+      meshPolyhedraVisibilitySchema,
+      { id, visibility },
+      {
+        response_function: () => {
+          meshPolyhedraCommonStyle.meshPolyhedraStyle(id).visibility =
+            visibility
+          console.log(
+            setMeshPolyhedraVisibility.name,
+            { id },
+            meshPolyhedraVisibility(id),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    meshPolyhedraVisibility,
+    setMeshPolyhedraVisibility,
+  }
+}

package/internal/stores/{model → data_style/model}/blocks.js

@@ -3,7 +3,7 @@ import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schem
 
 // Local imports
 import { useDataStore } from "@ogw_front/stores/data"
-import { useDataStyleStateStore } from "../data_style_state"
+import { useDataStyleStateStore } from "../state"
 import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants

package/internal/stores/{model → data_style/model}/corners.js

@@ -3,7 +3,7 @@ import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schem
 
 // Local imports
 import { useDataStore } from "@ogw_front/stores/data"
-import { useDataStyleStateStore } from "../data_style_state"
+import { useDataStyleStateStore } from "../state"
 import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants

package/internal/stores/{model → data_style/model}/edges.js

@@ -2,7 +2,7 @@
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 
 // Local imports
-import { useDataStyleStateStore } from "../data_style_state"
+import { useDataStyleStateStore } from "../state"
 import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants

package/internal/stores/{model → data_style/model}/index.js

@@ -3,7 +3,7 @@ import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schem
 
 // Local imports
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer"
-import { useDataStyleStateStore } from "../data_style_state"
+import { useDataStyleStateStore } from "../state"
 import { useDataStore } from "@ogw_front/stores/data"
 import { useViewerStore } from "@ogw_front/stores/viewer"
 import { useModelSurfacesStyle } from "./surfaces"
@@ -98,7 +98,7 @@ export default function useModelStyle() {
     )
   }
 
-  async function setModelMeshComponentVisibility(
+  async function setModelMeshComponentsVisibility(
     id,
     component_geode_ids,
     visibility,
@@ -188,7 +188,7 @@ export default function useModelStyle() {
     modelMeshComponentVisibility,
     setModelVisibility,
     setModelColor,
-    setModelMeshComponentVisibility,
+    setModelMeshComponentsVisibility,
     applyModelStyle,
     setModelMeshComponentsDefaultStyle,
     ...useModelBlocksStyle(),

package/internal/stores/{model → data_style/model}/lines.js

@@ -3,7 +3,7 @@ import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schem
 
 // Local imports
 import { useDataStore } from "@ogw_front/stores/data"
-import { useDataStyleStateStore } from "../data_style_state"
+import { useDataStyleStateStore } from "../state"
 import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants

package/internal/stores/{model → data_style/model}/points.js

@@ -2,7 +2,7 @@
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 
 // Local imports
-import { useDataStyleStateStore } from "../data_style_state"
+import { useDataStyleStateStore } from "../state"
 import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants

package/internal/stores/{model → data_style/model}/surfaces.js

@@ -3,7 +3,7 @@ import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schem
 
 // Local imports
 import { useDataStore } from "@ogw_front/stores/data"
-import { useDataStyleStateStore } from "../data_style_state"
+import { useDataStyleStateStore } from "../state"
 import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants

package/internal/stores/{data_style_state.js → data_style/state.js}

@@ -1,5 +1,3 @@
-import { reactive, computed } from "vue"
-
 export const useDataStyleStateStore = defineStore("dataStyleState", () => {
   const styles = reactive({})
 
@@ -23,5 +21,10 @@ export const useDataStyleStateStore = defineStore("dataStyleState", () => {
     return styles[id]
   }
 
-  return { getStyle, styles, objectVisibility, selectedObjects }
+  return {
+    getStyle,
+    styles,
+    objectVisibility,
+    selectedObjects,
+  }
 })

package/package.json

@@ -2,7 +2,7 @@
   "name": "@geode/opengeodeweb-front",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "type": "module",
-  "version": "10.2.1",
+  "version": "10.3.0",
   "main": "./nuxt.config.js",
   "scripts": {
     "lint": "eslint --fix --ext .js,.vue --ignore-path .gitignore .",

package/tests/integration/microservices/back/requirements.txt

@@ -5,4 +5,4 @@
 #    pip-compile --output-file=tests/integration/microservices/back/requirements.txt tests/integration/microservices/back/requirements.in
 #
 
-opengeodeweb-back==6.*,>=6.1.0
+opengeodeweb-back==6.*,>=6.1.3

package/tests/integration/microservices/viewer/requirements.txt

@@ -5,4 +5,4 @@
 #    pip-compile --output-file=tests/integration/microservices/viewer/requirements.txt tests/integration/microservices/viewer/requirements.in
 #
 
-opengeodeweb-viewer==1.*,>=1.15.1rc2
+opengeodeweb-viewer==1.*,>=1.15.2

package/tests/integration/stores/data_style/mesh/cells.nuxt.test.js

@@ -87,21 +87,21 @@ describe("Mesh cells", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshCellsVertexAttribute(
+      const result = dataStyleStore.setMeshCellsVertexAttributeName(
         id,
-        vertex_attribute,
+        vertex_attribute.name,
       )
       expect(result).toBeInstanceOf(Promise)
       await result
       expect(spy).toHaveBeenCalledWith(
-        mesh_cells_schemas.vertex_attribute,
+        mesh_cells_schemas.attribute.vertex.name,
         { id, ...vertex_attribute },
         {
           response_function: expect.any(Function),
         },
       )
-      expect(dataStyleStore.meshCellsVertexAttribute(id)).toStrictEqual(
-        vertex_attribute,
+      expect(dataStyleStore.meshCellsVertexAttributeName(id)).toBe(
+        vertex_attribute.name,
       )
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
@@ -112,21 +112,21 @@ describe("Mesh cells", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshCellsCellAttribute(
+      const result = dataStyleStore.setMeshCellsCellAttributeName(
         id,
-        cell_attribute,
+        cell_attribute.name,
       )
       expect(result).toBeInstanceOf(Promise)
       await result
       expect(spy).toHaveBeenCalledWith(
-        mesh_cells_schemas.cell_attribute,
+        mesh_cells_schemas.attribute.cell.name,
         { id, ...cell_attribute },
         {
           response_function: expect.any(Function),
         },
       )
-      expect(dataStyleStore.meshCellsCellAttribute(id)).toStrictEqual(
-        cell_attribute,
+      expect(dataStyleStore.meshCellsCellAttributeName(id)).toBe(
+        cell_attribute.name,
       )
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
@@ -141,22 +141,22 @@ describe("Mesh cells", () => {
         {
           name: "vertex",
           function: () =>
-            dataStyleStore.setMeshCellsVertexAttribute(id, vertex_attribute),
+            dataStyleStore.setMeshCellsVertexAttributeName(
+              id,
+              vertex_attribute.name,
+            ),
         },
         {
           name: "cell",
           function: () =>
-            dataStyleStore.setMeshCellsCellAttribute(id, cell_attribute),
+            dataStyleStore.setMeshCellsCellAttributeName(
+              id,
+              cell_attribute.name,
+            ),
         },
       ]
       for (let i = 0; i < coloringTypes.length; i++) {
         if (coloringTypes[i].function) {
-          expect(() =>
-            dataStyleStore.setMeshCellsActiveColoring(
-              id,
-              coloringTypes[i].name,
-            ),
-          ).toThrowError()
           await coloringTypes[i].function()
         }
         const result = dataStyleStore.setMeshCellsActiveColoring(

package/tests/integration/stores/data_style/mesh/edges.nuxt.test.js

@@ -83,16 +83,19 @@ describe("Mesh edges", () => {
       const viewerStore = useViewerStore()
 
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshEdgesVertexAttribute(id, vertex_attribute)
+      await dataStyleStore.setMeshEdgesVertexAttributeName(
+        id,
+        vertex_attribute.name,
+      )
       expect(spy).toHaveBeenCalledWith(
-        mesh_edges_schemas.vertex_attribute,
+        mesh_edges_schemas.attribute.vertex.name,
         { id, ...vertex_attribute },
         {
           response_function: expect.any(Function),
         },
       )
-      expect(dataStyleStore.meshEdgesVertexAttribute(id)).toStrictEqual(
-        vertex_attribute,
+      expect(dataStyleStore.meshEdgesVertexAttributeName(id)).toBe(
+        vertex_attribute.name,
       )
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
@@ -102,16 +105,19 @@ describe("Mesh edges", () => {
       const viewerStore = useViewerStore()
 
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshEdgesEdgeAttribute(id, edge_attribute)
+      await dataStyleStore.setMeshEdgesEdgeAttributeName(
+        id,
+        edge_attribute.name,
+      )
       expect(spy).toHaveBeenCalledWith(
-        mesh_edges_schemas.edge_attribute,
+        mesh_edges_schemas.attribute.edge.name,
         { id, ...edge_attribute },
         {
           response_function: expect.any(Function),
         },
       )
-      expect(dataStyleStore.meshEdgesEdgeAttribute(id)).toStrictEqual(
-        edge_attribute,
+      expect(dataStyleStore.meshEdgesEdgeAttributeName(id)).toBe(
+        edge_attribute.name,
       )
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
@@ -124,22 +130,22 @@ describe("Mesh edges", () => {
         {
           name: "vertex",
           function: () =>
-            dataStyleStore.setMeshEdgesVertexAttribute(id, vertex_attribute),
+            dataStyleStore.setMeshEdgesVertexAttributeName(
+              id,
+              vertex_attribute.name,
+            ),
         },
         {
           name: "edge",
           function: () =>
-            dataStyleStore.setMeshEdgesEdgeAttribute(id, edge_attribute),
+            dataStyleStore.setMeshEdgesEdgeAttributeName(
+              id,
+              edge_attribute.name,
+            ),
         },
       ]
       for (let i = 0; i < coloringTypes.length; i++) {
         if (coloringTypes[i].function) {
-          expect(() =>
-            dataStyleStore.setMeshEdgesActiveColoring(
-              id,
-              coloringTypes[i].name,
-            ),
-          ).toThrowError()
           await coloringTypes[i].function()
         }
         const result = dataStyleStore.setMeshEdgesActiveColoring(

package/tests/integration/stores/data_style/mesh/index.nuxt.test.js

@@ -59,7 +59,7 @@ describe("Mesh", () => {
   })
 
   describe("Apply mesh default style", () => {
-    test("test", async () => {
+    test("Apply mesh default style", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const result = dataStyleStore.applyMeshStyle(id)

package/tests/integration/stores/data_style/mesh/points.nuxt.test.js

@@ -89,17 +89,14 @@ describe("Mesh points", () => {
         {
           name: "vertex",
           function: () =>
-            dataStyleStore.setMeshPointsVertexAttribute(id, vertex_attribute),
+            dataStyleStore.setMeshPointsVertexAttributeName(
+              id,
+              vertex_attribute.name,
+            ),
         },
       ]
       for (let i = 0; i < coloringTypes.length; i++) {
         if (coloringTypes[i].function) {
-          expect(() =>
-            dataStyleStore.setMeshPointsActiveColoring(
-              id,
-              coloringTypes[i].name,
-            ),
-          ).toThrowError()
           await coloringTypes[i].function()
         }
         const result = dataStyleStore.setMeshPointsActiveColoring(
@@ -135,22 +132,27 @@ describe("Mesh points", () => {
       expect(dataStyleStore.meshPointsSize(id)).toBe(size)
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
+  })
 
-    test("Points vertex attribute", async () => {
+  describe("Points vertex attribute", () => {
+    test("test coloring", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
 
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshPointsVertexAttribute(id, vertex_attribute)
+      await dataStyleStore.setMeshPointsVertexAttributeName(
+        id,
+        vertex_attribute.name,
+      )
       expect(spy).toHaveBeenCalledWith(
-        mesh_points_schemas.vertex_attribute,
+        mesh_points_schemas.attribute.vertex.name,
         { id, ...vertex_attribute },
         {
           response_function: expect.any(Function),
         },
       )
-      expect(dataStyleStore.meshPointsVertexAttribute(id)).toStrictEqual(
-        vertex_attribute,
+      expect(dataStyleStore.meshPointsVertexAttributeName(id)).toBe(
+        vertex_attribute.name,
       )
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })

package/tests/integration/stores/data_style/mesh/polygons.nuxt.test.js

@@ -87,21 +87,21 @@ describe("Mesh polygons", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshPolygonsVertexAttribute(
+      const result = dataStyleStore.setMeshPolygonsVertexAttributeName(
         id,
-        vertex_attribute,
+        vertex_attribute.name,
       )
       expect(result).toBeInstanceOf(Promise)
       await result
       expect(spy).toHaveBeenCalledWith(
-        mesh_polygons_schemas.vertex_attribute,
+        mesh_polygons_schemas.attribute.vertex.name,
         { id, ...vertex_attribute },
         {
           response_function: expect.any(Function),
         },
       )
-      expect(dataStyleStore.meshPolygonsVertexAttribute(id)).toStrictEqual(
-        vertex_attribute,
+      expect(dataStyleStore.meshPolygonsVertexAttributeName(id)).toBe(
+        vertex_attribute.name,
       )
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
@@ -112,21 +112,21 @@ describe("Mesh polygons", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshPolygonsPolygonAttribute(
+      const result = dataStyleStore.setMeshPolygonsPolygonAttributeName(
         id,
-        polygon_attribute,
+        polygon_attribute.name,
       )
       expect(result).toBeInstanceOf(Promise)
       await result
       expect(spy).toHaveBeenCalledWith(
-        mesh_polygons_schemas.polygon_attribute,
+        mesh_polygons_schemas.attribute.polygon.name,
         { id, ...polygon_attribute },
         {
           response_function: expect.any(Function),
         },
       )
-      expect(dataStyleStore.meshPolygonsPolygonAttribute(id)).toStrictEqual(
-        polygon_attribute,
+      expect(dataStyleStore.meshPolygonsPolygonAttributeName(id)).toBe(
+        polygon_attribute.name,
       )
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
@@ -141,26 +141,23 @@ describe("Mesh polygons", () => {
         {
           name: "vertex",
           function: () =>
-            dataStyleStore.setMeshPolygonsVertexAttribute(id, vertex_attribute),
+            dataStyleStore.setMeshPolygonsVertexAttributeName(
+              id,
+              vertex_attribute.name,
+            ),
         },
         {
           name: "polygon",
           function: () =>
-            dataStyleStore.setMeshPolygonsPolygonAttribute(
+            dataStyleStore.setMeshPolygonsPolygonAttributeName(
               id,
-              polygon_attribute,
+              polygon_attribute.name,
             ),
         },
       ]
 
       for (let i = 0; i < coloringTypes.length; i++) {
         if (coloringTypes[i].function) {
-          expect(() =>
-            dataStyleStore.setMeshPolygonsActiveColoring(
-              id,
-              coloringTypes[i].name,
-            ),
-          ).toThrowError()
           await coloringTypes[i].function()
         }
         const result = dataStyleStore.setMeshPolygonsActiveColoring(