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

package/internal/stores/data_style/mesh/points/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 { useMeshPointsCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
+import { useMeshPointsCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
 const meshPointsVertexAttributeSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.points.attribute.vertex
+  viewer_schemas.opengeodeweb_viewer.mesh.points.attribute.vertex;
 
 export function useMeshPointsVertexAttributeStyle() {
-  const viewerStore = useViewerStore()
-  const meshPointsCommonStyle = useMeshPointsCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshPointsCommonStyle = useMeshPointsCommonStyle();
 
   function meshPointsVertexAttribute(id) {
-    return meshPointsCommonStyle.meshPointsColoring(id).vertex
+    return meshPointsCommonStyle.meshPointsColoring(id).vertex;
   }
 
   function meshPointsVertexAttributeStoredConfig(id, name) {
-    const { storedConfigs } = meshPointsVertexAttribute(id)
+    const { storedConfigs } = meshPointsVertexAttribute(id);
     if (name in storedConfigs) {
-      return storedConfigs[name]
+      return storedConfigs[name];
     }
     return setMeshPointsVertexAttributeStoredConfig(id, name, {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    })
+    });
   }
 
-  function setMeshPointsVertexAttributeStoredConfig(
-    id,
-    name,
-    { minimum, maximum, colorMap },
-  ) {
-    const { storedConfigs } = meshPointsVertexAttribute(id)
-    storedConfigs[name] = { minimum, maximum, colorMap }
-    return storedConfigs[name]
+  function setMeshPointsVertexAttributeStoredConfig(id, name, { minimum, maximum, colorMap }) {
+    const { storedConfigs } = meshPointsVertexAttribute(id);
+    storedConfigs[name] = { minimum, maximum, colorMap };
+    return storedConfigs[name];
   }
 
   function meshPointsVertexAttributeName(id) {
-    console.log(
-      meshPointsVertexAttributeName.name,
-      { id },
-      meshPointsVertexAttribute(id),
-    )
-    return meshPointsVertexAttribute(id).name
+    console.log(meshPointsVertexAttributeName.name, { id }, meshPointsVertexAttribute(id));
+    return meshPointsVertexAttribute(id).name;
   }
   function setMeshPointsVertexAttributeName(id, name) {
-    console.log(setMeshPointsVertexAttributeName.name, { id, name })
+    console.log(setMeshPointsVertexAttributeName.name, { id, name });
     return viewerStore.request(
       meshPointsVertexAttributeSchemas.name,
       { id, name },
       {
         response_function: async () => {
-          meshPointsVertexAttribute(id).name = name
-          const { minimum, maximum } = meshPointsVertexAttributeStoredConfig(
-            id,
-            name,
-          )
-          await setMeshPointsVertexAttributeRange(id, minimum, maximum)
+          meshPointsVertexAttribute(id).name = name;
+          const { minimum, maximum } = meshPointsVertexAttributeStoredConfig(id, name);
+          await setMeshPointsVertexAttributeRange(id, minimum, maximum);
           console.log(
             setMeshPointsVertexAttributeName.name,
             { id },
             meshPointsVertexAttributeName(id),
-          )
+          );
         },
       },
-    )
+    );
   }
 
   function meshPointsVertexAttributeRange(id) {
-    const name = meshPointsVertexAttributeName(id)
-    const storedConfig = meshPointsVertexAttributeStoredConfig(id, name)
-    const { minimum, maximum } = storedConfig
-    return [minimum, maximum]
+    const name = meshPointsVertexAttributeName(id);
+    const storedConfig = meshPointsVertexAttributeStoredConfig(id, name);
+    const { minimum, maximum } = storedConfig;
+    return [minimum, maximum];
   }
   function setMeshPointsVertexAttributeRange(id, minimum, maximum) {
-    const name = meshPointsVertexAttributeName(id)
-    const storedConfig = meshPointsVertexAttributeStoredConfig(id, name)
-    storedConfig.minimum = minimum
-    storedConfig.maximum = maximum
-    return setMeshPointsVertexAttributeColorMap(id, storedConfig.colorMap)
+    const name = meshPointsVertexAttributeName(id);
+    const storedConfig = meshPointsVertexAttributeStoredConfig(id, name);
+    storedConfig.minimum = minimum;
+    storedConfig.maximum = maximum;
+    return setMeshPointsVertexAttributeColorMap(id, storedConfig.colorMap);
   }
 
   function meshPointsVertexAttributeColorMap(id) {
-    const name = meshPointsVertexAttributeName(id)
-    const storedConfig = meshPointsVertexAttributeStoredConfig(id, name)
-    const { colorMap } = storedConfig
-    return colorMap
+    const name = meshPointsVertexAttributeName(id);
+    const storedConfig = meshPointsVertexAttributeStoredConfig(id, name);
+    const { colorMap } = storedConfig;
+    return colorMap;
   }
   function setMeshPointsVertexAttributeColorMap(id, colorMap) {
-    const name = meshPointsVertexAttributeName(id)
-    const storedConfig = meshPointsVertexAttributeStoredConfig(id, name)
+    const name = meshPointsVertexAttributeName(id);
+    const storedConfig = meshPointsVertexAttributeStoredConfig(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(setMeshPointsVertexAttributeColorMap.name, {
       id,
       minimum,
       maximum,
       colorMap,
-    })
+    });
     return viewerStore.request(
       meshPointsVertexAttributeSchemas.color_map,
       { id, points, minimum, maximum },
       {
         response_function: () => {
-          storedConfig.colorMap = colorMap
+          storedConfig.colorMap = colorMap;
           console.log(
             setMeshPointsVertexAttributeColorMap.name,
             { id },
             meshPointsVertexAttributeColorMap(id),
-          )
+          );
         },
       },
-    )
+    );
   }
 
   return {
@@ -135,5 +124,5 @@ export function useMeshPointsVertexAttributeStyle() {
     setMeshPointsVertexAttributeName,
     setMeshPointsVertexAttributeRange,
     setMeshPointsVertexAttributeColorMap,
-  }
+  };
 }

package/internal/stores/data_style/mesh/points/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 { useMeshPointsCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshPointsCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshPointsVisibilitySchema =
-  viewer_schemas.opengeodeweb_viewer.mesh.points.visibility
+const meshPointsVisibilitySchema = viewer_schemas.opengeodeweb_viewer.mesh.points.visibility;
 
 export function useMeshPointsVisibilityStyle() {
-  const viewerStore = useViewerStore()
-  const meshPointsCommonStyle = useMeshPointsCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshPointsCommonStyle = useMeshPointsCommonStyle();
 
   function meshPointsVisibility(id) {
-    return meshPointsCommonStyle.meshPointsStyle(id).visibility
+    return meshPointsCommonStyle.meshPointsStyle(id).visibility;
   }
   function setMeshPointsVisibility(id, visibility) {
     return viewerStore.request(
@@ -22,19 +21,15 @@ export function useMeshPointsVisibilityStyle() {
       { id, visibility },
       {
         response_function: () => {
-          meshPointsCommonStyle.meshPointsStyle(id).visibility = visibility
-          console.log(
-            setMeshPointsVisibility.name,
-            { id },
-            meshPointsVisibility(id),
-          )
+          meshPointsCommonStyle.meshPointsStyle(id).visibility = visibility;
+          console.log(setMeshPointsVisibility.name, { id }, meshPointsVisibility(id));
         },
       },
-    )
+    );
   }
 
   return {
     meshPointsVisibility,
     setMeshPointsVisibility,
-  }
+  };
 }

package/internal/stores/data_style/mesh/polygons/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 { useMeshPolygonsCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshPolygonsCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshPolygonsColorSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.polygons.color
+const meshPolygonsColorSchemas = viewer_schemas.opengeodeweb_viewer.mesh.polygons.color;
 
 export function useMeshPolygonsColorStyle() {
-  const viewerStore = useViewerStore()
-  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle();
 
   function meshPolygonsColor(id) {
-    return meshPolygonsCommonStyle.meshPolygonsColoring(id).color
+    return meshPolygonsCommonStyle.meshPolygonsColoring(id).color;
   }
   function setMeshPolygonsColor(id, color) {
     return viewerStore.request(
@@ -22,19 +21,15 @@ export function useMeshPolygonsColorStyle() {
       { id, color },
       {
         response_function: () => {
-          meshPolygonsCommonStyle.meshPolygonsColoring(id).color = color
-          console.log(
-            setMeshPolygonsColor.name,
-            { id },
-            JSON.stringify(meshPolygonsColor(id)),
-          )
+          meshPolygonsCommonStyle.meshPolygonsColoring(id).color = color;
+          console.log(setMeshPolygonsColor.name, { id }, JSON.stringify(meshPolygonsColor(id)));
         },
       },
-    )
+    );
   }
 
   return {
     meshPolygonsColor,
     setMeshPolygonsColor,
-  }
+  };
 }

package/internal/stores/data_style/mesh/polygons/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 useMeshPolygonsCommonStyle() {
-  const dataStyleStateStore = useDataStyleStateStore()
+  const dataStyleStateStore = useDataStyleStateStore();
 
   function meshPolygonsStyle(id) {
-    return dataStyleStateStore.getStyle(id).polygons
+    return dataStyleStateStore.getStyle(id).polygons;
   }
 
   function meshPolygonsColoring(id) {
-    return meshPolygonsStyle(id).coloring
+    return meshPolygonsStyle(id).coloring;
   }
 
   function meshPolygonsActiveColoring(id) {
-    return meshPolygonsColoring(id).active
+    return meshPolygonsColoring(id).active;
   }
 
   return {
     meshPolygonsStyle,
     meshPolygonsColoring,
     meshPolygonsActiveColoring,
-  }
+  };
 }

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

@@ -1,66 +1,60 @@
 // Third party imports
 
 // Local imports
-import { useMeshPolygonsColorStyle } from "./color"
-import { useMeshPolygonsCommonStyle } from "./common"
-import { useMeshPolygonsPolygonAttributeStyle } from "./polygon"
-import { useMeshPolygonsTexturesStyle } from "./textures"
-import { useMeshPolygonsVertexAttributeStyle } from "./vertex"
-import { useMeshPolygonsVisibilityStyle } from "./visibility"
+import { useMeshPolygonsColorStyle } from "./color";
+import { useMeshPolygonsCommonStyle } from "./common";
+import { useMeshPolygonsPolygonAttributeStyle } from "./polygon";
+import { useMeshPolygonsTexturesStyle } from "./textures";
+import { useMeshPolygonsVertexAttributeStyle } from "./vertex";
+import { useMeshPolygonsVisibilityStyle } from "./visibility";
 
 // Local constants
 
 export function useMeshPolygonsStyle() {
-  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle()
-  const meshPolygonsVisibility = useMeshPolygonsVisibilityStyle()
-  const meshPolygonsColorStyle = useMeshPolygonsColorStyle()
-  const meshPolygonsTexturesStyle = useMeshPolygonsTexturesStyle()
-  const meshPolygonsVertexAttributeStyle = useMeshPolygonsVertexAttributeStyle()
-  const meshPolygonsPolygonAttributeStyle =
-    useMeshPolygonsPolygonAttributeStyle()
+  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle();
+  const meshPolygonsVisibility = useMeshPolygonsVisibilityStyle();
+  const meshPolygonsColorStyle = useMeshPolygonsColorStyle();
+  const meshPolygonsTexturesStyle = useMeshPolygonsTexturesStyle();
+  const meshPolygonsVertexAttributeStyle = useMeshPolygonsVertexAttributeStyle();
+  const meshPolygonsPolygonAttributeStyle = useMeshPolygonsPolygonAttributeStyle();
 
   async function setMeshPolygonsActiveColoring(id, type) {
-    const coloring = meshPolygonsCommonStyle.meshPolygonsColoring(id)
-    coloring.active = type
+    const coloring = meshPolygonsCommonStyle.meshPolygonsColoring(id);
+    coloring.active = type;
     console.log(
       setMeshPolygonsActiveColoring.name,
       { id },
       meshPolygonsCommonStyle.meshPolygonsActiveColoring(id),
-    )
+    );
     if (type === "color") {
       return meshPolygonsColorStyle.setMeshPolygonsColor(
         id,
         meshPolygonsColorStyle.meshPolygonsColor(id),
-      )
-    } else if (type === "textures") {
-      const textures = meshPolygonsTexturesStyle.meshPolygonsTextures(id)
+      );
+    }
+    if (type === "textures") {
+      const textures = meshPolygonsTexturesStyle.meshPolygonsTextures(id);
       if (textures === undefined) {
-        return Promise.resolve()
+        return;
       }
-      return meshPolygonsTexturesStyle.setMeshPolygonsTextures(id, textures)
-    } else if (type === "vertex") {
-      const name =
-        meshPolygonsVertexAttributeStyle.meshPolygonsVertexAttributeName(id)
+      return meshPolygonsTexturesStyle.setMeshPolygonsTextures(id, textures);
+    }
+    if (type === "vertex") {
+      const name = meshPolygonsVertexAttributeStyle.meshPolygonsVertexAttributeName(id);
       if (name === undefined) {
-        return Promise.resolve()
+        return;
       }
-      return meshPolygonsVertexAttributeStyle.setMeshPolygonsVertexAttributeName(
-        id,
-        name,
-      )
-    } else if (type === "polygon") {
-      const name =
-        meshPolygonsPolygonAttributeStyle.meshPolygonsPolygonAttributeName(id)
+      return meshPolygonsVertexAttributeStyle.setMeshPolygonsVertexAttributeName(id, name);
+    }
+    if (type === "polygon") {
+      const name = meshPolygonsPolygonAttributeStyle.meshPolygonsPolygonAttributeName(id);
       if (name === undefined) {
-        return Promise.resolve()
+        return;
       }
-      await meshPolygonsPolygonAttributeStyle.setMeshPolygonsPolygonAttributeName(
-        id,
-        name,
-      )
-    } else {
-      throw new Error(`Unknown mesh polygons coloring type: ${type}`)
+      await meshPolygonsPolygonAttributeStyle.setMeshPolygonsPolygonAttributeName(id, name);
+      return;
     }
+    throw new Error(`Unknown mesh polygons coloring type: ${type}`);
   }
 
   function applyMeshPolygonsStyle(id) {
@@ -69,11 +63,8 @@ export function useMeshPolygonsStyle() {
         id,
         meshPolygonsVisibility.meshPolygonsVisibility(id),
       ),
-      setMeshPolygonsActiveColoring(
-        id,
-        meshPolygonsCommonStyle.meshPolygonsActiveColoring(id),
-      ),
-    ])
+      setMeshPolygonsActiveColoring(id, meshPolygonsCommonStyle.meshPolygonsActiveColoring(id)),
+    ]);
   }
 
   return {
@@ -85,5 +76,5 @@ export function useMeshPolygonsStyle() {
     ...meshPolygonsTexturesStyle,
     ...meshPolygonsVertexAttributeStyle,
     ...meshPolygonsPolygonAttributeStyle,
-  }
+  };
 }

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

@@ -1,47 +1,43 @@
 // 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 meshPolygonsPolygonAttributeSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.polygons.attribute.polygon
+  viewer_schemas.opengeodeweb_viewer.mesh.polygons.attribute.polygon;
 
 export function useMeshPolygonsPolygonAttributeStyle() {
-  const viewerStore = useViewerStore()
-  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle();
 
   function meshPolygonsPolygonAttribute(id) {
-    return meshPolygonsCommonStyle.meshPolygonsColoring(id).polygon
+    return meshPolygonsCommonStyle.meshPolygonsColoring(id).polygon;
   }
 
   function meshPolygonsPolygonAttributeStoredConfig(id, name) {
-    const { storedConfigs } = meshPolygonsPolygonAttribute(id)
+    const { storedConfigs } = meshPolygonsPolygonAttribute(id);
     if (name in storedConfigs) {
-      return storedConfigs[name]
+      return storedConfigs[name];
     }
     return setMeshPolygonsPolygonAttributeStoredConfig(id, name, {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    })
+    });
   }
 
-  function setMeshPolygonsPolygonAttributeStoredConfig(
-    id,
-    name,
-    { minimum, maximum, colorMap },
-  ) {
-    const { storedConfigs } = meshPolygonsPolygonAttribute(id)
-    storedConfigs[name] = { minimum, maximum, colorMap }
-    return storedConfigs[name]
+  function setMeshPolygonsPolygonAttributeStoredConfig(id, name, { minimum, maximum, colorMap }) {
+    const { storedConfigs } = meshPolygonsPolygonAttribute(id);
+    storedConfigs[name] = { minimum, maximum, colorMap };
+    return storedConfigs[name];
   }
 
   function meshPolygonsPolygonAttributeName(id) {
-    return meshPolygonsPolygonAttribute(id).name
+    return meshPolygonsPolygonAttribute(id).name;
   }
   function setMeshPolygonsPolygonAttributeName(id, name) {
     return viewerStore.request(
@@ -49,73 +45,66 @@ export function useMeshPolygonsPolygonAttributeStyle() {
       { id, name },
       {
         response_function: async () => {
-          meshPolygonsPolygonAttribute(id).name = name
-          const { minimum, maximum } = meshPolygonsPolygonAttributeStoredConfig(
-            id,
-            name,
-          )
-          await setMeshPolygonsPolygonAttributeRange(id, minimum, maximum)
+          meshPolygonsPolygonAttribute(id).name = name;
+          const { minimum, maximum } = meshPolygonsPolygonAttributeStoredConfig(id, name);
+          await setMeshPolygonsPolygonAttributeRange(id, minimum, maximum);
           console.log(
             setMeshPolygonsPolygonAttributeName.name,
             { id },
             meshPolygonsPolygonAttributeName(id),
-          )
+          );
         },
       },
-    )
+    );
   }
   function meshPolygonsPolygonAttributeRange(id) {
-    const name = meshPolygonsPolygonAttributeName(id)
-    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name)
-    const { minimum, maximum } = storedConfig
-    console.log(
-      meshPolygonsPolygonAttributeRange.name,
-      { id },
-      { minimum, maximum },
-    )
-    return [minimum, maximum]
+    const name = meshPolygonsPolygonAttributeName(id);
+    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name);
+    const { minimum, maximum } = storedConfig;
+    console.log(meshPolygonsPolygonAttributeRange.name, { id }, { minimum, maximum });
+    return [minimum, maximum];
   }
   function setMeshPolygonsPolygonAttributeRange(id, minimum, maximum) {
-    const name = meshPolygonsPolygonAttributeName(id)
-    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name)
-    storedConfig.minimum = minimum
-    storedConfig.maximum = maximum
-    return setMeshPolygonsPolygonAttributeColorMap(id, storedConfig.colorMap)
+    const name = meshPolygonsPolygonAttributeName(id);
+    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name);
+    storedConfig.minimum = minimum;
+    storedConfig.maximum = maximum;
+    return setMeshPolygonsPolygonAttributeColorMap(id, storedConfig.colorMap);
   }
 
   function meshPolygonsPolygonAttributeColorMap(id) {
-    const name = meshPolygonsPolygonAttributeName(id)
-    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name)
-    const { colorMap } = storedConfig
-    return colorMap
+    const name = meshPolygonsPolygonAttributeName(id);
+    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name);
+    const { colorMap } = storedConfig;
+    return colorMap;
   }
   function setMeshPolygonsPolygonAttributeColorMap(id, colorMap) {
-    const name = meshPolygonsPolygonAttributeName(id)
-    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name)
+    const name = meshPolygonsPolygonAttributeName(id);
+    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(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(
       meshPolygonsPolygonAttributeSchemas.color_map,
       { id, points, minimum, maximum },
       {
         response_function: () => {
-          storedConfig.colorMap = colorMap
+          storedConfig.colorMap = colorMap;
           console.log(
             setMeshPolygonsPolygonAttributeColorMap.name,
             { id },
             meshPolygonsPolygonAttributeColorMap(id),
-          )
+          );
         },
       },
-    )
+    );
   }
 
   return {
@@ -126,5 +115,5 @@ export function useMeshPolygonsPolygonAttributeStyle() {
     setMeshPolygonsPolygonAttributeName,
     setMeshPolygonsPolygonAttributeRange,
     setMeshPolygonsPolygonAttributeColorMap,
-  }
+  };
 }

package/internal/stores/data_style/mesh/polygons/textures.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 meshPolygonsTexturesSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.polygons.apply_textures
+const meshPolygonsTexturesSchemas = viewer_schemas.opengeodeweb_viewer.mesh.polygons.apply_textures;
 
 export function useMeshPolygonsTexturesStyle() {
-  const viewerStore = useViewerStore()
-  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle();
 
   function meshPolygonsTextures(id) {
-    return meshPolygonsCommonStyle.meshPolygonsColoring(id).textures
+    return meshPolygonsCommonStyle.meshPolygonsColoring(id).textures;
   }
   function setMeshPolygonsTextures(id, textures) {
     return viewerStore.request(
@@ -22,19 +21,15 @@ export function useMeshPolygonsTexturesStyle() {
       { id, textures },
       {
         response_function: () => {
-          meshPolygonsCommonStyle.meshPolygonsColoring(id).textures = textures
-          console.log(
-            setMeshPolygonsTextures.name,
-            { id },
-            meshPolygonsTextures(id),
-          )
+          meshPolygonsCommonStyle.meshPolygonsColoring(id).textures = textures;
+          console.log(setMeshPolygonsTextures.name, { id }, meshPolygonsTextures(id));
         },
       },
-    )
+    );
   }
 
   return {
     meshPolygonsTextures,
     setMeshPolygonsTextures,
-  }
+  };
 }