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

package/internal/stores/data_style/mesh/edges/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 { useMeshEdgesCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
+import { useMeshEdgesCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
 const meshEdgesVertexAttributeSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.edges.attribute.vertex
+  viewer_schemas.opengeodeweb_viewer.mesh.edges.attribute.vertex;
 
 export function useMeshEdgesVertexAttributeStyle() {
-  const viewerStore = useViewerStore()
-  const meshEdgesCommonStyle = useMeshEdgesCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
 
   function meshEdgesVertexAttribute(id) {
-    return meshEdgesCommonStyle.meshEdgesColoring(id).vertex
+    return meshEdgesCommonStyle.meshEdgesColoring(id).vertex;
   }
 
   function meshEdgesVertexAttributeStoredConfig(id, name) {
-    const { storedConfigs } = meshEdgesVertexAttribute(id)
+    const { storedConfigs } = meshEdgesVertexAttribute(id);
     if (name in storedConfigs) {
-      return storedConfigs[name]
+      return storedConfigs[name];
     }
     return setMeshEdgesVertexAttributeStoredConfig(id, name, {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    })
+    });
   }
 
-  function setMeshEdgesVertexAttributeStoredConfig(
-    id,
-    name,
-    { minimum, maximum, colorMap },
-  ) {
-    const { storedConfigs } = meshEdgesVertexAttribute(id)
-    storedConfigs[name] = { minimum, maximum, colorMap }
-    return storedConfigs[name]
+  function setMeshEdgesVertexAttributeStoredConfig(id, name, { minimum, maximum, colorMap }) {
+    const { storedConfigs } = meshEdgesVertexAttribute(id);
+    storedConfigs[name] = { minimum, maximum, colorMap };
+    return storedConfigs[name];
   }
 
   function meshEdgesVertexAttributeName(id) {
-    console.log(
-      meshEdgesVertexAttributeName.name,
-      { id },
-      meshEdgesVertexAttribute(id),
-    )
-    return meshEdgesVertexAttribute(id).name
+    console.log(meshEdgesVertexAttributeName.name, { id }, meshEdgesVertexAttribute(id));
+    return meshEdgesVertexAttribute(id).name;
   }
   function setMeshEdgesVertexAttributeName(id, name) {
-    console.log(setMeshEdgesVertexAttributeName.name, { id, name })
+    console.log(setMeshEdgesVertexAttributeName.name, { id, name });
     return viewerStore.request(
       meshEdgesVertexAttributeSchemas.name,
       { id, name },
       {
         response_function: async () => {
-          meshEdgesVertexAttribute(id).name = name
-          const { minimum, maximum } = meshEdgesVertexAttributeStoredConfig(
-            id,
-            name,
-          )
-          await setMeshEdgesVertexAttributeRange(id, minimum, maximum)
+          meshEdgesVertexAttribute(id).name = name;
+          const { minimum, maximum } = meshEdgesVertexAttributeStoredConfig(id, name);
+          await setMeshEdgesVertexAttributeRange(id, minimum, maximum);
           console.log(
             setMeshEdgesVertexAttributeName.name,
             { id },
             meshEdgesVertexAttributeName(id),
-          )
+          );
         },
       },
-    )
+    );
   }
 
   function meshEdgesVertexAttributeRange(id) {
-    const name = meshEdgesVertexAttributeName(id)
-    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name)
-    const { minimum, maximum } = storedConfig
-    return [minimum, maximum]
+    const name = meshEdgesVertexAttributeName(id);
+    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name);
+    const { minimum, maximum } = storedConfig;
+    return [minimum, maximum];
   }
   function setMeshEdgesVertexAttributeRange(id, minimum, maximum) {
-    const name = meshEdgesVertexAttributeName(id)
-    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name)
-    storedConfig.minimum = minimum
-    storedConfig.maximum = maximum
-    return setMeshEdgesVertexAttributeColorMap(id, storedConfig.colorMap)
+    const name = meshEdgesVertexAttributeName(id);
+    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name);
+    storedConfig.minimum = minimum;
+    storedConfig.maximum = maximum;
+    return setMeshEdgesVertexAttributeColorMap(id, storedConfig.colorMap);
   }
 
   function meshEdgesVertexAttributeColorMap(id) {
-    const name = meshEdgesVertexAttributeName(id)
-    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name)
-    const { colorMap } = storedConfig
-    return colorMap
+    const name = meshEdgesVertexAttributeName(id);
+    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name);
+    const { colorMap } = storedConfig;
+    return colorMap;
   }
   function setMeshEdgesVertexAttributeColorMap(id, colorMap) {
-    const name = meshEdgesVertexAttributeName(id)
-    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name)
+    const name = meshEdgesVertexAttributeName(id);
+    const storedConfig = meshEdgesVertexAttributeStoredConfig(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(setMeshEdgesVertexAttributeColorMap.name, {
       id,
       minimum,
       maximum,
       colorMap,
-    })
+    });
     return viewerStore.request(
       meshEdgesVertexAttributeSchemas.color_map,
       { id, points, minimum, maximum },
       {
         response_function: () => {
-          storedConfig.colorMap = colorMap
+          storedConfig.colorMap = colorMap;
           console.log(
             setMeshEdgesVertexAttributeColorMap.name,
             { id },
             meshEdgesVertexAttributeColorMap(id),
-          )
+          );
         },
       },
-    )
+    );
   }
 
   return {
@@ -135,5 +124,5 @@ export function useMeshEdgesVertexAttributeStyle() {
     setMeshEdgesVertexAttributeName,
     setMeshEdgesVertexAttributeRange,
     setMeshEdgesVertexAttributeColorMap,
-  }
+  };
 }

package/internal/stores/data_style/mesh/edges/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 { useMeshEdgesCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshEdgesCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshEdgesVisibilitySchema =
-  viewer_schemas.opengeodeweb_viewer.mesh.edges.visibility
+const meshEdgesVisibilitySchema = viewer_schemas.opengeodeweb_viewer.mesh.edges.visibility;
 
 export function useMeshEdgesVisibilityStyle() {
-  const viewerStore = useViewerStore()
-  const meshEdgesCommonStyle = useMeshEdgesCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
 
   function meshEdgesVisibility(id) {
-    return meshEdgesCommonStyle.meshEdgesStyle(id).visibility
+    return meshEdgesCommonStyle.meshEdgesStyle(id).visibility;
   }
   function setMeshEdgesVisibility(id, visibility) {
     return viewerStore.request(
@@ -22,19 +21,15 @@ export function useMeshEdgesVisibilityStyle() {
       { id, visibility },
       {
         response_function: () => {
-          meshEdgesCommonStyle.meshEdgesStyle(id).visibility = visibility
-          console.log(
-            setMeshEdgesVisibility.name,
-            { id },
-            meshEdgesVisibility(id),
-          )
+          meshEdgesCommonStyle.meshEdgesStyle(id).visibility = visibility;
+          console.log(setMeshEdgesVisibility.name, { id }, meshEdgesVisibility(id));
         },
       },
-    )
+    );
   }
 
   return {
     meshEdgesVisibility,
     setMeshEdgesVisibility,
-  }
+  };
 }

package/internal/stores/data_style/mesh/edges/width.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 { useMeshEdgesCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshEdgesCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshEdgesWidthSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.edges.width
+const meshEdgesWidthSchemas = viewer_schemas.opengeodeweb_viewer.mesh.edges.width;
 
 export function useMeshEdgesWidthStyle() {
-  const viewerStore = useViewerStore()
-  const meshEdgesCommonStyle = useMeshEdgesCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
 
   function meshEdgesWidth(id) {
-    return meshEdgesCommonStyle.meshEdgesStyle(id).width
+    return meshEdgesCommonStyle.meshEdgesStyle(id).width;
   }
   function setMeshEdgesWidth(id, width) {
     return viewerStore.request(
@@ -22,19 +21,15 @@ export function useMeshEdgesWidthStyle() {
       { id, width },
       {
         response_function: () => {
-          meshEdgesCommonStyle.meshEdgesStyle(id).width = width
-          console.log(
-            setMeshEdgesWidth.name,
-            { id },
-            JSON.stringify(meshEdgesWidth(id)),
-          )
+          meshEdgesCommonStyle.meshEdgesStyle(id).width = width;
+          console.log(setMeshEdgesWidth.name, { id }, JSON.stringify(meshEdgesWidth(id)));
         },
       },
-    )
+    );
   }
 
   return {
     meshEdgesWidth,
     setMeshEdgesWidth,
-  }
+  };
 }

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

@@ -1,32 +1,32 @@
 // 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 { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
-import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state"
-import { useMeshCellsStyle } from "./cells"
-import { useMeshEdgesStyle } from "./edges"
-import { useMeshPointsStyle } from "./points"
-import { useMeshPolygonsStyle } from "./polygons"
-import { useMeshPolyhedraStyle } from "./polyhedra"
+import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state";
+import { useMeshCellsStyle } from "./cells";
+import { useMeshEdgesStyle } from "./edges";
+import { useMeshPointsStyle } from "./points";
+import { useMeshPolygonsStyle } from "./polygons";
+import { useMeshPolyhedraStyle } from "./polyhedra";
 
 // Local constants
-const meshSchemas = viewer_schemas.opengeodeweb_viewer.mesh
+const meshSchemas = viewer_schemas.opengeodeweb_viewer.mesh;
 
 export function useMeshStyle() {
-  const hybridViewerStore = useHybridViewerStore()
-  const viewerStore = useViewerStore()
-  const dataStyleState = useDataStyleStateStore()
-  const meshPointsStyle = useMeshPointsStyle()
-  const meshEdgesStyle = useMeshEdgesStyle()
-  const meshCellsStyle = useMeshCellsStyle()
-  const meshPolygonsStyle = useMeshPolygonsStyle()
-  const meshPolyhedraStyle = useMeshPolyhedraStyle()
+  const hybridViewerStore = useHybridViewerStore();
+  const viewerStore = useViewerStore();
+  const dataStyleState = useDataStyleStateStore();
+  const meshPointsStyle = useMeshPointsStyle();
+  const meshEdgesStyle = useMeshEdgesStyle();
+  const meshCellsStyle = useMeshCellsStyle();
+  const meshPolygonsStyle = useMeshPolygonsStyle();
+  const meshPolyhedraStyle = useMeshPolyhedraStyle();
 
   function meshVisibility(id) {
-    return dataStyleState.getStyle(id).visibility
+    return dataStyleState.getStyle(id).visibility;
   }
   function setMeshVisibility(id, visibility) {
     return viewerStore.request(
@@ -34,35 +34,35 @@ export function useMeshStyle() {
       { id, visibility },
       {
         response_function: () => {
-          hybridViewerStore.setVisibility(id, visibility)
-          dataStyleState.getStyle(id).visibility = visibility
-          console.log(setMeshVisibility.name, { id }, meshVisibility(id))
+          hybridViewerStore.setVisibility(id, visibility);
+          dataStyleState.getStyle(id).visibility = visibility;
+          console.log(setMeshVisibility.name, { id }, meshVisibility(id));
         },
       },
-    )
+    );
   }
 
   function applyMeshStyle(id) {
-    const style = dataStyleState.getStyle(id)
-    const promise_array = []
+    const style = dataStyleState.getStyle(id);
+    const promise_array = [];
     for (const [key, value] of Object.entries(style)) {
       if (key === "visibility") {
-        promise_array.push(setMeshVisibility(id, value))
+        promise_array.push(setMeshVisibility(id, value));
       } else if (key === "points") {
-        promise_array.push(meshPointsStyle.applyMeshPointsStyle(id))
+        promise_array.push(meshPointsStyle.applyMeshPointsStyle(id));
       } else if (key === "edges") {
-        promise_array.push(meshEdgesStyle.applyMeshEdgesStyle(id))
+        promise_array.push(meshEdgesStyle.applyMeshEdgesStyle(id));
       } else if (key === "cells") {
-        promise_array.push(meshCellsStyle.applyMeshCellsStyle(id))
+        promise_array.push(meshCellsStyle.applyMeshCellsStyle(id));
       } else if (key === "polygons") {
-        promise_array.push(meshPolygonsStyle.applyMeshPolygonsStyle(id))
+        promise_array.push(meshPolygonsStyle.applyMeshPolygonsStyle(id));
       } else if (key === "polyhedra") {
-        promise_array.push(meshPolyhedraStyle.applyMeshPolyhedraStyle(id))
+        promise_array.push(meshPolyhedraStyle.applyMeshPolyhedraStyle(id));
       } else if (key !== "attributes") {
-        throw new Error(`Unknown mesh key: ${key}`)
+        throw new Error(`Unknown mesh key: ${key}`);
       }
     }
-    return Promise.all(promise_array)
+    return Promise.all(promise_array);
   }
 
   return {
@@ -74,5 +74,5 @@ export function useMeshStyle() {
     ...meshCellsStyle,
     ...meshPolygonsStyle,
     ...meshPolyhedraStyle,
-  }
+  };
 }

package/internal/stores/data_style/mesh/points/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 { useMeshPointsCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshPointsCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshPointsColorSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.points.color
+const meshPointsColorSchemas = viewer_schemas.opengeodeweb_viewer.mesh.points.color;
 
 export function useMeshPointsColorStyle() {
-  const viewerStore = useViewerStore()
-  const meshPointsCommonStyle = useMeshPointsCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshPointsCommonStyle = useMeshPointsCommonStyle();
 
   function meshPointsColor(id) {
-    return meshPointsCommonStyle.meshPointsColoring(id).color
+    return meshPointsCommonStyle.meshPointsColoring(id).color;
   }
   function setMeshPointsColor(id, color) {
     return viewerStore.request(
@@ -22,19 +21,15 @@ export function useMeshPointsColorStyle() {
       { id, color },
       {
         response_function: () => {
-          meshPointsCommonStyle.meshPointsColoring(id).color = color
-          console.log(
-            setMeshPointsColor.name,
-            { id },
-            JSON.stringify(meshPointsColor(id)),
-          )
+          meshPointsCommonStyle.meshPointsColoring(id).color = color;
+          console.log(setMeshPointsColor.name, { id }, JSON.stringify(meshPointsColor(id)));
         },
       },
-    )
+    );
   }
 
   return {
     meshPointsColor,
     setMeshPointsColor,
-  }
+  };
 }

package/internal/stores/data_style/mesh/points/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 useMeshPointsCommonStyle() {
-  const dataStyleStateStore = useDataStyleStateStore()
+  const dataStyleStateStore = useDataStyleStateStore();
 
   function meshPointsStyle(id) {
-    return dataStyleStateStore.getStyle(id).points
+    return dataStyleStateStore.getStyle(id).points;
   }
 
   function meshPointsColoring(id) {
-    return meshPointsStyle(id).coloring
+    return meshPointsStyle(id).coloring;
   }
 
   function meshPointsActiveColoring(id) {
-    return meshPointsColoring(id).active
+    return meshPointsColoring(id).active;
   }
 
   return {
     meshPointsStyle,
     meshPointsColoring,
     meshPointsActiveColoring,
-  }
+  };
 }

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

@@ -1,63 +1,55 @@
 // Third party imports
 
 // Local imports
-import { useMeshPointsColorStyle } from "./color"
-import { useMeshPointsCommonStyle } from "./common"
-import { useMeshPointsSizeStyle } from "./size"
-import { useMeshPointsVertexAttributeStyle } from "./vertex"
-import { useMeshPointsVisibilityStyle } from "./visibility"
+import { useMeshPointsColorStyle } from "./color";
+import { useMeshPointsCommonStyle } from "./common";
+import { useMeshPointsSizeStyle } from "./size";
+import { useMeshPointsVertexAttributeStyle } from "./vertex";
+import { useMeshPointsVisibilityStyle } from "./visibility";
 
 // Local constants
 
 export function useMeshPointsStyle() {
-  const meshPointsCommonStyle = useMeshPointsCommonStyle()
-  const meshPointsVisibility = useMeshPointsVisibilityStyle()
-  const meshPointsColorStyle = useMeshPointsColorStyle()
-  const meshPointsSizeStyle = useMeshPointsSizeStyle()
-  const meshPointsVertexAttributeStyle = useMeshPointsVertexAttributeStyle()
+  const meshPointsCommonStyle = useMeshPointsCommonStyle();
+  const meshPointsVisibility = useMeshPointsVisibilityStyle();
+  const meshPointsColorStyle = useMeshPointsColorStyle();
+  const meshPointsSizeStyle = useMeshPointsSizeStyle();
+  const meshPointsVertexAttributeStyle = useMeshPointsVertexAttributeStyle();
 
   async function setMeshPointsActiveColoring(id, type) {
-    const coloring = meshPointsCommonStyle.meshPointsColoring(id)
-    coloring.active = type
+    const coloring = meshPointsCommonStyle.meshPointsColoring(id);
+    coloring.active = type;
     console.log(
       setMeshPointsActiveColoring.name,
       { id },
       meshPointsCommonStyle.meshPointsActiveColoring(id),
-    )
+    );
     if (type === "color") {
-      return meshPointsColorStyle.setMeshPointsColor(
-        id,
-        meshPointsColorStyle.meshPointsColor(id),
-      )
-    } else if (type === "textures") {
-      const textures = meshPointsTexturesStore.meshPointsTextures(id)
+      return meshPointsColorStyle.setMeshPointsColor(id, meshPointsColorStyle.meshPointsColor(id));
+    }
+    if (type === "textures") {
+      const textures = meshPointsTexturesStore.meshPointsTextures(id);
       if (textures === undefined) {
-        return Promise.resolve()
+        return;
       }
-      return meshPointsTexturesStore.setMeshPointsTextures(id, textures)
-    } else if (type === "vertex") {
-      const name =
-        meshPointsVertexAttributeStyle.meshPointsVertexAttributeName(id)
+      return meshPointsTexturesStore.setMeshPointsTextures(id, textures);
+    }
+    if (type === "vertex") {
+      const name = meshPointsVertexAttributeStyle.meshPointsVertexAttributeName(id);
       if (name === undefined) {
-        return Promise.resolve()
+        return;
       }
-      return meshPointsVertexAttributeStyle.setMeshPointsVertexAttributeName(
-        id,
-        name,
-      )
-    } else if (type === "polygon") {
-      const name =
-        meshPointsPolygonAttributeStyleStore.meshPointsPolygonAttributeName(id)
+      return meshPointsVertexAttributeStyle.setMeshPointsVertexAttributeName(id, name);
+    }
+    if (type === "polygon") {
+      const name = meshPointsPolygonAttributeStyleStore.meshPointsPolygonAttributeName(id);
       if (name === undefined) {
-        return Promise.resolve()
+        return;
       }
-      await meshPointsPolygonAttributeStyleStore.setMeshPointsPolygonAttributeName(
-        id,
-        name,
-      )
-    } else {
-      throw new Error(`Unknown mesh points coloring type: ${type}`)
+      await meshPointsPolygonAttributeStyleStore.setMeshPointsPolygonAttributeName(id, name);
+      return;
     }
+    throw new Error(`Unknown mesh points coloring type: ${type}`);
   }
 
   function applyMeshPointsStyle(id) {
@@ -66,15 +58,9 @@ export function useMeshPointsStyle() {
         id,
         meshPointsVisibility.meshPointsVisibility(id),
       ),
-      meshPointsSizeStyle.setMeshPointsSize(
-        id,
-        meshPointsSizeStyle.meshPointsSize(id),
-      ),
-      setMeshPointsActiveColoring(
-        id,
-        meshPointsCommonStyle.meshPointsActiveColoring(id),
-      ),
-    ])
+      meshPointsSizeStyle.setMeshPointsSize(id, meshPointsSizeStyle.meshPointsSize(id)),
+      setMeshPointsActiveColoring(id, meshPointsCommonStyle.meshPointsActiveColoring(id)),
+    ]);
   }
 
   return {
@@ -85,5 +71,5 @@ export function useMeshPointsStyle() {
     ...meshPointsColorStyle,
     ...meshPointsSizeStyle,
     ...meshPointsVertexAttributeStyle,
-  }
+  };
 }

package/internal/stores/data_style/mesh/points/size.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 meshPointsSizeSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.points.size
+const meshPointsSizeSchemas = viewer_schemas.opengeodeweb_viewer.mesh.points.size;
 
 export function useMeshPointsSizeStyle() {
-  const viewerStore = useViewerStore()
-  const meshPointsCommonStyle = useMeshPointsCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshPointsCommonStyle = useMeshPointsCommonStyle();
 
   function meshPointsSize(id) {
-    return meshPointsCommonStyle.meshPointsStyle(id).size
+    return meshPointsCommonStyle.meshPointsStyle(id).size;
   }
   function setMeshPointsSize(id, size) {
     return viewerStore.request(
@@ -22,19 +21,15 @@ export function useMeshPointsSizeStyle() {
       { id, size },
       {
         response_function: () => {
-          meshPointsCommonStyle.meshPointsStyle(id).size = size
-          console.log(
-            setMeshPointsSize.name,
-            { id },
-            JSON.stringify(meshPointsSize(id)),
-          )
+          meshPointsCommonStyle.meshPointsStyle(id).size = size;
+          console.log(setMeshPointsSize.name, { id }, JSON.stringify(meshPointsSize(id)));
         },
       },
-    )
+    );
   }
 
   return {
     meshPointsSize,
     setMeshPointsSize,
-  }
+  };
 }