@geode/opengeodeweb-front 10.6.2 → 10.6.3-rc.1

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

@@ -1,130 +1,119 @@
 // Third party imports
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 // Local imports
-import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap"
-import { useMeshPolygonsCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
+import { useMeshPolygonsCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
 const meshPolygonsVertexAttributeSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.polygons.attribute.vertex
+  viewer_schemas.opengeodeweb_viewer.mesh.polygons.attribute.vertex;
 
 export function useMeshPolygonsVertexAttributeStyle() {
-  const viewerStore = useViewerStore()
-  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle();
 
   function meshPolygonsVertexAttribute(id) {
-    return meshPolygonsCommonStyle.meshPolygonsColoring(id).vertex
+    return meshPolygonsCommonStyle.meshPolygonsColoring(id).vertex;
   }
 
   function meshPolygonsVertexAttributeStoredConfig(id, name) {
-    const { storedConfigs } = meshPolygonsVertexAttribute(id)
+    const { storedConfigs } = meshPolygonsVertexAttribute(id);
     if (name in storedConfigs) {
-      return storedConfigs[name]
+      return storedConfigs[name];
     }
     return setMeshPolygonsVertexAttributeStoredConfig(id, name, {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    })
+    });
   }
 
-  function setMeshPolygonsVertexAttributeStoredConfig(
-    id,
-    name,
-    { minimum, maximum, colorMap },
-  ) {
-    const { storedConfigs } = meshPolygonsVertexAttribute(id)
-    storedConfigs[name] = { minimum, maximum, colorMap }
-    return storedConfigs[name]
+  function setMeshPolygonsVertexAttributeStoredConfig(id, name, { minimum, maximum, colorMap }) {
+    const { storedConfigs } = meshPolygonsVertexAttribute(id);
+    storedConfigs[name] = { minimum, maximum, colorMap };
+    return storedConfigs[name];
   }
 
   function meshPolygonsVertexAttributeName(id) {
-    console.log(
-      meshPolygonsVertexAttributeName.name,
-      { id },
-      meshPolygonsVertexAttribute(id),
-    )
-    return meshPolygonsVertexAttribute(id).name
+    console.log(meshPolygonsVertexAttributeName.name, { id }, meshPolygonsVertexAttribute(id));
+    return meshPolygonsVertexAttribute(id).name;
   }
   function setMeshPolygonsVertexAttributeName(id, name) {
-    console.log(setMeshPolygonsVertexAttributeName.name, { id, name })
+    console.log(setMeshPolygonsVertexAttributeName.name, { id, name });
     return viewerStore.request(
       meshPolygonsVertexAttributeSchemas.name,
       { id, name },
       {
         response_function: async () => {
-          meshPolygonsVertexAttribute(id).name = name
-          const { minimum, maximum } = meshPolygonsVertexAttributeStoredConfig(
-            id,
-            name,
-          )
-          await setMeshPolygonsVertexAttributeRange(id, minimum, maximum)
+          meshPolygonsVertexAttribute(id).name = name;
+          const { minimum, maximum } = meshPolygonsVertexAttributeStoredConfig(id, name);
+          await setMeshPolygonsVertexAttributeRange(id, minimum, maximum);
           console.log(
             setMeshPolygonsVertexAttributeName.name,
             { id },
             meshPolygonsVertexAttributeName(id),
-          )
+          );
         },
       },
-    )
+    );
   }
 
   function meshPolygonsVertexAttributeRange(id) {
-    const name = meshPolygonsVertexAttributeName(id)
-    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name)
-    const { minimum, maximum } = storedConfig
-    return [minimum, maximum]
+    const name = meshPolygonsVertexAttributeName(id);
+    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name);
+    const { minimum, maximum } = storedConfig;
+    return [minimum, maximum];
   }
   function setMeshPolygonsVertexAttributeRange(id, minimum, maximum) {
-    const name = meshPolygonsVertexAttributeName(id)
-    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name)
-    storedConfig.minimum = minimum
-    storedConfig.maximum = maximum
-    return setMeshPolygonsVertexAttributeColorMap(id, storedConfig.colorMap)
+    const name = meshPolygonsVertexAttributeName(id);
+    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name);
+    storedConfig.minimum = minimum;
+    storedConfig.maximum = maximum;
+    return setMeshPolygonsVertexAttributeColorMap(id, storedConfig.colorMap);
   }
 
   function meshPolygonsVertexAttributeColorMap(id) {
-    const name = meshPolygonsVertexAttributeName(id)
-    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name)
-    const { colorMap } = storedConfig
-    return colorMap
+    const name = meshPolygonsVertexAttributeName(id);
+    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name);
+    const { colorMap } = storedConfig;
+    return colorMap;
   }
   function setMeshPolygonsVertexAttributeColorMap(id, colorMap) {
-    const name = meshPolygonsVertexAttributeName(id)
-    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name)
+    const name = meshPolygonsVertexAttributeName(id);
+    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name);
     if (
       storedConfig.minimum === undefined ||
       storedConfig.maximum === undefined ||
       colorMap === undefined
     ) {
-      storedConfig.colorMap = colorMap
-      return
+      storedConfig.colorMap = colorMap;
+      return;
     }
-    const points = getRGBPointsFromPreset(colorMap)
-    const { minimum, maximum } = storedConfig
+    const points = getRGBPointsFromPreset(colorMap);
+    const { minimum, maximum } = storedConfig;
 
     console.log(setMeshPolygonsVertexAttributeColorMap.name, {
       id,
       minimum,
       maximum,
       colorMap,
-    })
+    });
     return viewerStore.request(
       meshPolygonsVertexAttributeSchemas.color_map,
       { id, points, minimum, maximum },
       {
         response_function: () => {
-          storedConfig.colorMap = colorMap
+          storedConfig.colorMap = colorMap;
           console.log(
             setMeshPolygonsVertexAttributeColorMap.name,
             { id },
             meshPolygonsVertexAttributeColorMap(id),
-          )
+          );
         },
       },
-    )
+    );
   }
 
   return {
@@ -135,5 +124,5 @@ export function useMeshPolygonsVertexAttributeStyle() {
     setMeshPolygonsVertexAttributeName,
     setMeshPolygonsVertexAttributeRange,
     setMeshPolygonsVertexAttributeColorMap,
-  }
+  };
 }

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

@@ -1,20 +1,19 @@
 // Third party imports
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 // Local imports
-import { useMeshPolygonsCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshPolygonsCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshPolygonsVisibilitySchema =
-  viewer_schemas.opengeodeweb_viewer.mesh.polygons.visibility
+const meshPolygonsVisibilitySchema = viewer_schemas.opengeodeweb_viewer.mesh.polygons.visibility;
 
 export function useMeshPolygonsVisibilityStyle() {
-  const viewerStore = useViewerStore()
-  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle();
 
   function meshPolygonsVisibility(id) {
-    return meshPolygonsCommonStyle.meshPolygonsStyle(id).visibility
+    return meshPolygonsCommonStyle.meshPolygonsStyle(id).visibility;
   }
   function setMeshPolygonsVisibility(id, visibility) {
     return viewerStore.request(
@@ -22,19 +21,15 @@ export function useMeshPolygonsVisibilityStyle() {
       { id, visibility },
       {
         response_function: () => {
-          meshPolygonsCommonStyle.meshPolygonsStyle(id).visibility = visibility
-          console.log(
-            setMeshPolygonsVisibility.name,
-            { id },
-            meshPolygonsVisibility(id),
-          )
+          meshPolygonsCommonStyle.meshPolygonsStyle(id).visibility = visibility;
+          console.log(setMeshPolygonsVisibility.name, { id }, meshPolygonsVisibility(id));
         },
       },
-    )
+    );
   }
 
   return {
     meshPolygonsVisibility,
     setMeshPolygonsVisibility,
-  }
+  };
 }

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

@@ -1,20 +1,19 @@
 // Third party imports
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 // Local imports
-import { useMeshPolyhedraCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshPolyhedraCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshPolyhedraColorSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.color
+const meshPolyhedraColorSchemas = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.color;
 
 export function useMeshPolyhedraColorStyle() {
-  const viewerStore = useViewerStore()
-  const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle();
 
   function meshPolyhedraColor(id) {
-    return meshPolyhedraCommonStyle.meshPolyhedraColoring(id).color
+    return meshPolyhedraCommonStyle.meshPolyhedraColoring(id).color;
   }
   function setMeshPolyhedraColor(id, color) {
     return viewerStore.request(
@@ -22,19 +21,15 @@ export function useMeshPolyhedraColorStyle() {
       { id, color },
       {
         response_function: () => {
-          meshPolyhedraCommonStyle.meshPolyhedraColoring(id).color = color
-          console.log(
-            setMeshPolyhedraColor.name,
-            { id },
-            JSON.stringify(meshPolyhedraColor(id)),
-          )
+          meshPolyhedraCommonStyle.meshPolyhedraColoring(id).color = color;
+          console.log(setMeshPolyhedraColor.name, { id }, JSON.stringify(meshPolyhedraColor(id)));
         },
       },
-    )
+    );
   }
 
   return {
     meshPolyhedraColor,
     setMeshPolyhedraColor,
-  }
+  };
 }

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

@@ -1,23 +1,23 @@
-import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state"
+import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state";
 
 export function useMeshPolyhedraCommonStyle() {
-  const dataStyleStateStore = useDataStyleStateStore()
+  const dataStyleStateStore = useDataStyleStateStore();
 
   function meshPolyhedraStyle(id) {
-    return dataStyleStateStore.getStyle(id).polyhedra
+    return dataStyleStateStore.getStyle(id).polyhedra;
   }
 
   function meshPolyhedraColoring(id) {
-    return meshPolyhedraStyle(id).coloring
+    return meshPolyhedraStyle(id).coloring;
   }
 
   function meshPolyhedraActiveColoring(id) {
-    return meshPolyhedraColoring(id).active
+    return meshPolyhedraColoring(id).active;
   }
 
   return {
     meshPolyhedraStyle,
     meshPolyhedraColoring,
     meshPolyhedraActiveColoring,
-  }
+  };
 }

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

@@ -1,61 +1,51 @@
 // Third party imports
 
 // Local imports
-import { useMeshPolyhedraColorStyle } from "./color"
-import { useMeshPolyhedraCommonStyle } from "./common"
-import { useMeshPolyhedraPolyhedronAttributeStyle } from "./polyhedron"
-import { useMeshPolyhedraVertexAttributeStyle } from "./vertex"
-import { useMeshPolyhedraVisibilityStyle } from "./visibility"
+import { useMeshPolyhedraColorStyle } from "./color";
+import { useMeshPolyhedraCommonStyle } from "./common";
+import { useMeshPolyhedraPolyhedronAttributeStyle } from "./polyhedron";
+import { useMeshPolyhedraVertexAttributeStyle } from "./vertex";
+import { useMeshPolyhedraVisibilityStyle } from "./visibility";
 
 // Local constants
 
 export function useMeshPolyhedraStyle() {
-  const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle()
-  const meshPolyhedraVisibility = useMeshPolyhedraVisibilityStyle()
-  const meshPolyhedraColorStyle = useMeshPolyhedraColorStyle()
-  const meshPolyhedraVertexAttributeStyle =
-    useMeshPolyhedraVertexAttributeStyle()
-  const meshPolyhedraPolyhedronAttributeStyle =
-    useMeshPolyhedraPolyhedronAttributeStyle()
+  const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle();
+  const meshPolyhedraVisibility = useMeshPolyhedraVisibilityStyle();
+  const meshPolyhedraColorStyle = useMeshPolyhedraColorStyle();
+  const meshPolyhedraVertexAttributeStyle = useMeshPolyhedraVertexAttributeStyle();
+  const meshPolyhedraPolyhedronAttributeStyle = useMeshPolyhedraPolyhedronAttributeStyle();
 
   async function setMeshPolyhedraActiveColoring(id, type) {
-    const coloring = meshPolyhedraCommonStyle.meshPolyhedraColoring(id)
-    coloring.active = type
+    const coloring = meshPolyhedraCommonStyle.meshPolyhedraColoring(id);
+    coloring.active = type;
     console.log(
       setMeshPolyhedraActiveColoring.name,
       { id },
       meshPolyhedraCommonStyle.meshPolyhedraActiveColoring(id),
-    )
+    );
     if (type === "color") {
       return meshPolyhedraColorStyle.setMeshPolyhedraColor(
         id,
         meshPolyhedraColorStyle.meshPolyhedraColor(id),
-      )
-    } else if (type === "vertex") {
-      const name =
-        meshPolyhedraVertexAttributeStyle.meshPolyhedraVertexAttributeName(id)
+      );
+    }
+    if (type === "vertex") {
+      const name = meshPolyhedraVertexAttributeStyle.meshPolyhedraVertexAttributeName(id);
       if (name === undefined) {
-        return Promise.resolve()
+        return;
       }
-      return meshPolyhedraVertexAttributeStyle.setMeshPolyhedraVertexAttributeName(
-        id,
-        name,
-      )
-    } else if (type === "polyhedron") {
-      const name =
-        meshPolyhedraPolyhedronAttributeStyle.meshPolyhedraPolyhedronAttributeName(
-          id,
-        )
+      return meshPolyhedraVertexAttributeStyle.setMeshPolyhedraVertexAttributeName(id, name);
+    }
+    if (type === "polyhedron") {
+      const name = meshPolyhedraPolyhedronAttributeStyle.meshPolyhedraPolyhedronAttributeName(id);
       if (name === undefined) {
-        return Promise.resolve()
+        return;
       }
-      await meshPolyhedraPolyhedronAttributeStyle.setMeshPolyhedraPolyhedronAttributeName(
-        id,
-        name,
-      )
-    } else {
-      throw new Error(`Unknown mesh polyhedra coloring type: ${type}`)
+      await meshPolyhedraPolyhedronAttributeStyle.setMeshPolyhedraPolyhedronAttributeName(id, name);
+      return;
     }
+    throw new Error(`Unknown mesh polyhedra coloring type: ${type}`);
   }
 
   function applyMeshPolyhedraStyle(id) {
@@ -64,11 +54,8 @@ export function useMeshPolyhedraStyle() {
         id,
         meshPolyhedraVisibility.meshPolyhedraVisibility(id),
       ),
-      setMeshPolyhedraActiveColoring(
-        id,
-        meshPolyhedraCommonStyle.meshPolyhedraActiveColoring(id),
-      ),
-    ])
+      setMeshPolyhedraActiveColoring(id, meshPolyhedraCommonStyle.meshPolyhedraActiveColoring(id)),
+    ]);
   }
 
   return {
@@ -79,5 +66,5 @@ export function useMeshPolyhedraStyle() {
     ...meshPolyhedraColorStyle,
     ...meshPolyhedraVertexAttributeStyle,
     ...meshPolyhedraPolyhedronAttributeStyle,
-  }
+  };
 }

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

@@ -1,33 +1,33 @@
 // Third party imports
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 // Local imports
-import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap"
-import { useMeshPolyhedraCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
+import { useMeshPolyhedraCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
 const meshPolyhedraPolyhedronAttributeSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.attribute.polyhedron
+  viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.attribute.polyhedron;
 
 export function useMeshPolyhedraPolyhedronAttributeStyle() {
-  const viewerStore = useViewerStore()
-  const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle();
 
   function meshPolyhedraPolyhedronAttribute(id) {
-    return meshPolyhedraCommonStyle.meshPolyhedraColoring(id).polyhedron
+    return meshPolyhedraCommonStyle.meshPolyhedraColoring(id).polyhedron;
   }
 
   function meshPolyhedraPolyhedronAttributeStoredConfig(id, name) {
-    const { storedConfigs } = meshPolyhedraPolyhedronAttribute(id)
+    const { storedConfigs } = meshPolyhedraPolyhedronAttribute(id);
     if (name in storedConfigs) {
-      return storedConfigs[name]
+      return storedConfigs[name];
     }
     return setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    })
+    });
   }
 
   function setMeshPolyhedraPolyhedronAttributeStoredConfig(
@@ -35,13 +35,13 @@ export function useMeshPolyhedraPolyhedronAttributeStyle() {
     name,
     { minimum, maximum, colorMap },
   ) {
-    const { storedConfigs } = meshPolyhedraPolyhedronAttribute(id)
-    storedConfigs[name] = { minimum, maximum, colorMap }
-    return storedConfigs[name]
+    const { storedConfigs } = meshPolyhedraPolyhedronAttribute(id);
+    storedConfigs[name] = { minimum, maximum, colorMap };
+    return storedConfigs[name];
   }
 
   function meshPolyhedraPolyhedronAttributeName(id) {
-    return meshPolyhedraPolyhedronAttribute(id).name
+    return meshPolyhedraPolyhedronAttribute(id).name;
   }
   function setMeshPolyhedraPolyhedronAttributeName(id, name) {
     return viewerStore.request(
@@ -49,69 +49,65 @@ export function useMeshPolyhedraPolyhedronAttributeStyle() {
       { id, name },
       {
         response_function: async () => {
-          meshPolyhedraPolyhedronAttribute(id).name = name
-          const { minimum, maximum } =
-            meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
-          await setMeshPolyhedraPolyhedronAttributeRange(id, minimum, maximum)
+          meshPolyhedraPolyhedronAttribute(id).name = name;
+          const { minimum, maximum } = meshPolyhedraPolyhedronAttributeStoredConfig(id, name);
+          await setMeshPolyhedraPolyhedronAttributeRange(id, minimum, maximum);
           console.log(
             setMeshPolyhedraPolyhedronAttributeName.name,
             { id },
             meshPolyhedraPolyhedronAttributeName(id),
-          )
+          );
         },
       },
-    )
+    );
   }
   function meshPolyhedraPolyhedronAttributeRange(id) {
-    const name = meshPolyhedraPolyhedronAttributeName(id)
-    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
-    const { minimum, maximum } = storedConfig
-    return [minimum, maximum]
+    const name = meshPolyhedraPolyhedronAttributeName(id);
+    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name);
+    const { minimum, maximum } = storedConfig;
+    return [minimum, maximum];
   }
   function setMeshPolyhedraPolyhedronAttributeRange(id, minimum, maximum) {
-    const name = meshPolyhedraPolyhedronAttributeName(id)
-    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
-    storedConfig.minimum = minimum
-    storedConfig.maximum = maximum
-    return setMeshPolyhedraPolyhedronAttributeColorMap(
-      id,
-      storedConfig.colorMap,
-    )
+    const name = meshPolyhedraPolyhedronAttributeName(id);
+    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name);
+    storedConfig.minimum = minimum;
+    storedConfig.maximum = maximum;
+    return setMeshPolyhedraPolyhedronAttributeColorMap(id, storedConfig.colorMap);
   }
 
   function meshPolyhedraPolyhedronAttributeColorMap(id) {
-    const name = meshPolyhedraPolyhedronAttributeName(id)
-    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
-    const { colorMap } = storedConfig
-    return colorMap
+    const name = meshPolyhedraPolyhedronAttributeName(id);
+    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name);
+    const { colorMap } = storedConfig;
+    return colorMap;
   }
   function setMeshPolyhedraPolyhedronAttributeColorMap(id, colorMap) {
-    const name = meshPolyhedraPolyhedronAttributeName(id)
-    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
+    const name = meshPolyhedraPolyhedronAttributeName(id);
+    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name);
     if (
       storedConfig.minimum === undefined ||
       storedConfig.maximum === undefined ||
       colorMap === undefined
     ) {
-      storedConfig.colorMap = colorMap
-      return
+      storedConfig.colorMap = colorMap;
+      return;
     }
-    const points = getRGBPointsFromPreset(colorMap)
-    const { minimum, maximum } = storedConfig
+    const points = getRGBPointsFromPreset(colorMap);
+    const { minimum, maximum } = storedConfig;
     return viewerStore.request(
       meshPolyhedraPolyhedronAttributeSchemas.color_map,
       { id, points, minimum, maximum },
       {
         response_function: () => {
-          storedConfig.colorMap = colorMap
+          storedConfig.colorMap = colorMap;
           console.log(
             setMeshPolyhedraPolyhedronAttributeColorMap.name,
             { id },
             meshPolyhedraPolyhedronAttributeColorMap(id),
-          )
+          );
         },
       },
-    )
+    );
   }
 
   return {
@@ -122,5 +118,5 @@ export function useMeshPolyhedraPolyhedronAttributeStyle() {
     setMeshPolyhedraPolyhedronAttributeName,
     setMeshPolyhedraPolyhedronAttributeRange,
     setMeshPolyhedraPolyhedronAttributeColorMap,
-  }
+  };
 }