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

package/internal/stores/data_style/mesh/cells/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 { useMeshCellsCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
+import { useMeshCellsCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
 const meshCellsVertexAttributeSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.cells.attribute.vertex
+  viewer_schemas.opengeodeweb_viewer.mesh.cells.attribute.vertex;
 
 export function useMeshCellsVertexAttributeStyle() {
-  const viewerStore = useViewerStore()
-  const meshCellsCommonStyle = useMeshCellsCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshCellsCommonStyle = useMeshCellsCommonStyle();
 
   function meshCellsVertexAttribute(id) {
-    return meshCellsCommonStyle.meshCellsColoring(id).vertex
+    return meshCellsCommonStyle.meshCellsColoring(id).vertex;
   }
 
   function meshCellsVertexAttributeStoredConfig(id, name) {
-    const { storedConfigs } = meshCellsVertexAttribute(id)
+    const { storedConfigs } = meshCellsVertexAttribute(id);
     if (name in storedConfigs) {
-      return storedConfigs[name]
+      return storedConfigs[name];
     }
     return setMeshCellsVertexAttributeStoredConfig(id, name, {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    })
+    });
   }
 
-  function setMeshCellsVertexAttributeStoredConfig(
-    id,
-    name,
-    { minimum, maximum, colorMap },
-  ) {
-    const { storedConfigs } = meshCellsVertexAttribute(id)
-    storedConfigs[name] = { minimum, maximum, colorMap }
-    return storedConfigs[name]
+  function setMeshCellsVertexAttributeStoredConfig(id, name, { minimum, maximum, colorMap }) {
+    const { storedConfigs } = meshCellsVertexAttribute(id);
+    storedConfigs[name] = { minimum, maximum, colorMap };
+    return storedConfigs[name];
   }
 
   function meshCellsVertexAttributeName(id) {
-    console.log(
-      meshCellsVertexAttributeName.name,
-      { id },
-      meshCellsVertexAttribute(id),
-    )
-    return meshCellsVertexAttribute(id).name
+    console.log(meshCellsVertexAttributeName.name, { id }, meshCellsVertexAttribute(id));
+    return meshCellsVertexAttribute(id).name;
   }
   function setMeshCellsVertexAttributeName(id, name) {
-    console.log(setMeshCellsVertexAttributeName.name, { id, name })
+    console.log(setMeshCellsVertexAttributeName.name, { id, name });
     return viewerStore.request(
       meshCellsVertexAttributeSchemas.name,
       { id, name },
       {
         response_function: async () => {
-          meshCellsVertexAttribute(id).name = name
-          const { minimum, maximum } = meshCellsVertexAttributeStoredConfig(
-            id,
-            name,
-          )
-          await setMeshCellsVertexAttributeRange(id, minimum, maximum)
+          meshCellsVertexAttribute(id).name = name;
+          const { minimum, maximum } = meshCellsVertexAttributeStoredConfig(id, name);
+          await setMeshCellsVertexAttributeRange(id, minimum, maximum);
           console.log(
             setMeshCellsVertexAttributeName.name,
             { id },
             meshCellsVertexAttributeName(id),
-          )
+          );
         },
       },
-    )
+    );
   }
 
   function meshCellsVertexAttributeRange(id) {
-    const name = meshCellsVertexAttributeName(id)
-    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name)
-    const { minimum, maximum } = storedConfig
-    return [minimum, maximum]
+    const name = meshCellsVertexAttributeName(id);
+    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name);
+    const { minimum, maximum } = storedConfig;
+    return [minimum, maximum];
   }
   function setMeshCellsVertexAttributeRange(id, minimum, maximum) {
-    const name = meshCellsVertexAttributeName(id)
-    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name)
-    storedConfig.minimum = minimum
-    storedConfig.maximum = maximum
-    return setMeshCellsVertexAttributeColorMap(id, storedConfig.colorMap)
+    const name = meshCellsVertexAttributeName(id);
+    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name);
+    storedConfig.minimum = minimum;
+    storedConfig.maximum = maximum;
+    return setMeshCellsVertexAttributeColorMap(id, storedConfig.colorMap);
   }
 
   function meshCellsVertexAttributeColorMap(id) {
-    const name = meshCellsVertexAttributeName(id)
-    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name)
-    const { colorMap } = storedConfig
-    return colorMap
+    const name = meshCellsVertexAttributeName(id);
+    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name);
+    const { colorMap } = storedConfig;
+    return colorMap;
   }
   function setMeshCellsVertexAttributeColorMap(id, colorMap) {
-    const name = meshCellsVertexAttributeName(id)
-    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name)
+    const name = meshCellsVertexAttributeName(id);
+    const storedConfig = meshCellsVertexAttributeStoredConfig(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(setMeshCellsVertexAttributeColorMap.name, {
       id,
       minimum,
       maximum,
       colorMap,
-    })
+    });
     return viewerStore.request(
       meshCellsVertexAttributeSchemas.color_map,
       { id, points, minimum, maximum },
       {
         response_function: () => {
-          storedConfig.colorMap = colorMap
+          storedConfig.colorMap = colorMap;
           console.log(
             setMeshCellsVertexAttributeColorMap.name,
             { id },
             meshCellsVertexAttributeColorMap(id),
-          )
+          );
         },
       },
-    )
+    );
   }
 
   return {
@@ -135,5 +124,5 @@ export function useMeshCellsVertexAttributeStyle() {
     setMeshCellsVertexAttributeName,
     setMeshCellsVertexAttributeRange,
     setMeshCellsVertexAttributeColorMap,
-  }
+  };
 }

package/internal/stores/data_style/mesh/cells/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 { useMeshCellsCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshCellsCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshCellsVisibilitySchema =
-  viewer_schemas.opengeodeweb_viewer.mesh.cells.visibility
+const meshCellsVisibilitySchema = viewer_schemas.opengeodeweb_viewer.mesh.cells.visibility;
 
 export function useMeshCellsVisibilityStyle() {
-  const viewerStore = useViewerStore()
-  const meshCellsCommonStyle = useMeshCellsCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshCellsCommonStyle = useMeshCellsCommonStyle();
 
   function meshCellsVisibility(id) {
-    return meshCellsCommonStyle.meshCellsStyle(id).visibility
+    return meshCellsCommonStyle.meshCellsStyle(id).visibility;
   }
   function setMeshCellsVisibility(id, visibility) {
     return viewerStore.request(
@@ -22,19 +21,15 @@ export function useMeshCellsVisibilityStyle() {
       { id, visibility },
       {
         response_function: () => {
-          meshCellsCommonStyle.meshCellsStyle(id).visibility = visibility
-          console.log(
-            setMeshCellsVisibility.name,
-            { id },
-            meshCellsVisibility(id),
-          )
+          meshCellsCommonStyle.meshCellsStyle(id).visibility = visibility;
+          console.log(setMeshCellsVisibility.name, { id }, meshCellsVisibility(id));
         },
       },
-    )
+    );
   }
 
   return {
     meshCellsVisibility,
     setMeshCellsVisibility,
-  }
+  };
 }

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

package/internal/stores/data_style/mesh/edges/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 useMeshEdgesCommonStyle() {
-  const dataStyleStateStore = useDataStyleStateStore()
+  const dataStyleStateStore = useDataStyleStateStore();
 
   function meshEdgesStyle(id) {
-    return dataStyleStateStore.getStyle(id).edges
+    return dataStyleStateStore.getStyle(id).edges;
   }
 
   function meshEdgesColoring(id) {
-    return meshEdgesStyle(id).coloring
+    return meshEdgesStyle(id).coloring;
   }
 
   function meshEdgesActiveColoring(id) {
-    return meshEdgesColoring(id).active
+    return meshEdgesColoring(id).active;
   }
 
   return {
     meshEdgesStyle,
     meshEdgesColoring,
     meshEdgesActiveColoring,
-  }
+  };
 }

package/internal/stores/data_style/mesh/edges/edge.js

@@ -1,130 +1,114 @@
 // 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 meshEdgesEdgeAttributeSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.edges.attribute.edge
+const meshEdgesEdgeAttributeSchemas = viewer_schemas.opengeodeweb_viewer.mesh.edges.attribute.edge;
 
 export function useMeshEdgesEdgeAttributeStyle() {
-  const viewerStore = useViewerStore()
-  const meshEdgesCommonStyle = useMeshEdgesCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
 
   function meshEdgesEdgeAttribute(id) {
-    return meshEdgesCommonStyle.meshEdgesColoring(id).edge
+    return meshEdgesCommonStyle.meshEdgesColoring(id).edge;
   }
 
   function meshEdgesEdgeAttributeStoredConfig(id, name) {
-    const { storedConfigs } = meshEdgesEdgeAttribute(id)
+    const { storedConfigs } = meshEdgesEdgeAttribute(id);
     if (name in storedConfigs) {
-      return storedConfigs[name]
+      return storedConfigs[name];
     }
     return setMeshEdgesEdgeAttributeStoredConfig(id, name, {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    })
+    });
   }
 
-  function setMeshEdgesEdgeAttributeStoredConfig(
-    id,
-    name,
-    { minimum, maximum, colorMap },
-  ) {
-    const { storedConfigs } = meshEdgesEdgeAttribute(id)
-    storedConfigs[name] = { minimum, maximum, colorMap }
-    return storedConfigs[name]
+  function setMeshEdgesEdgeAttributeStoredConfig(id, name, { minimum, maximum, colorMap }) {
+    const { storedConfigs } = meshEdgesEdgeAttribute(id);
+    storedConfigs[name] = { minimum, maximum, colorMap };
+    return storedConfigs[name];
   }
 
   function meshEdgesEdgeAttributeName(id) {
-    console.log(
-      meshEdgesEdgeAttributeName.name,
-      { id },
-      meshEdgesEdgeAttribute(id),
-    )
-    return meshEdgesEdgeAttribute(id).name
+    console.log(meshEdgesEdgeAttributeName.name, { id }, meshEdgesEdgeAttribute(id));
+    return meshEdgesEdgeAttribute(id).name;
   }
   function setMeshEdgesEdgeAttributeName(id, name) {
-    console.log(setMeshEdgesEdgeAttributeName.name, { id, name })
+    console.log(setMeshEdgesEdgeAttributeName.name, { id, name });
     return viewerStore.request(
       meshEdgesEdgeAttributeSchemas.name,
       { id, name },
       {
         response_function: async () => {
-          meshEdgesEdgeAttribute(id).name = name
-          const { minimum, maximum } = meshEdgesEdgeAttributeStoredConfig(
-            id,
-            name,
-          )
-          await setMeshEdgesEdgeAttributeRange(id, minimum, maximum)
-          console.log(
-            setMeshEdgesEdgeAttributeName.name,
-            { id },
-            meshEdgesEdgeAttributeName(id),
-          )
+          meshEdgesEdgeAttribute(id).name = name;
+          const { minimum, maximum } = meshEdgesEdgeAttributeStoredConfig(id, name);
+          await setMeshEdgesEdgeAttributeRange(id, minimum, maximum);
+          console.log(setMeshEdgesEdgeAttributeName.name, { id }, meshEdgesEdgeAttributeName(id));
         },
       },
-    )
+    );
   }
 
   function meshEdgesEdgeAttributeRange(id) {
-    const name = meshEdgesEdgeAttributeName(id)
-    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name)
-    const { minimum, maximum } = storedConfig
-    return [minimum, maximum]
+    const name = meshEdgesEdgeAttributeName(id);
+    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name);
+    const { minimum, maximum } = storedConfig;
+    return [minimum, maximum];
   }
   function setMeshEdgesEdgeAttributeRange(id, minimum, maximum) {
-    const name = meshEdgesEdgeAttributeName(id)
-    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name)
-    storedConfig.minimum = minimum
-    storedConfig.maximum = maximum
-    return setMeshEdgesEdgeAttributeColorMap(id, storedConfig.colorMap)
+    const name = meshEdgesEdgeAttributeName(id);
+    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name);
+    storedConfig.minimum = minimum;
+    storedConfig.maximum = maximum;
+    return setMeshEdgesEdgeAttributeColorMap(id, storedConfig.colorMap);
   }
 
   function meshEdgesEdgeAttributeColorMap(id) {
-    const name = meshEdgesEdgeAttributeName(id)
-    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name)
-    const { colorMap } = storedConfig
-    return colorMap
+    const name = meshEdgesEdgeAttributeName(id);
+    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name);
+    const { colorMap } = storedConfig;
+    return colorMap;
   }
   function setMeshEdgesEdgeAttributeColorMap(id, colorMap) {
-    const name = meshEdgesEdgeAttributeName(id)
-    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name)
+    const name = meshEdgesEdgeAttributeName(id);
+    const storedConfig = meshEdgesEdgeAttributeStoredConfig(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(setMeshEdgesEdgeAttributeColorMap.name, {
       id,
       minimum,
       maximum,
       colorMap,
-    })
+    });
     return viewerStore.request(
       meshEdgesEdgeAttributeSchemas.color_map,
       { id, points, minimum, maximum },
       {
         response_function: () => {
-          storedConfig.colorMap = colorMap
+          storedConfig.colorMap = colorMap;
           console.log(
             setMeshEdgesEdgeAttributeColorMap.name,
             { id },
             meshEdgesEdgeAttributeColorMap(id),
-          )
+          );
         },
       },
-    )
+    );
   }
 
   return {
@@ -135,5 +119,5 @@ export function useMeshEdgesEdgeAttributeStyle() {
     setMeshEdgesEdgeAttributeName,
     setMeshEdgesEdgeAttributeRange,
     setMeshEdgesEdgeAttributeColorMap,
-  }
+  };
 }

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

@@ -1,78 +1,64 @@
 // Third party imports
 
 // Local imports
-import { useMeshEdgesColorStyle } from "./color"
-import { useMeshEdgesCommonStyle } from "./common"
-import { useMeshEdgesEdgeAttributeStyle } from "./edge"
-import { useMeshEdgesVertexAttributeStyle } from "./vertex"
-import { useMeshEdgesVisibilityStyle } from "./visibility"
-import { useMeshEdgesWidthStyle } from "./width"
+import { useMeshEdgesColorStyle } from "./color";
+import { useMeshEdgesCommonStyle } from "./common";
+import { useMeshEdgesEdgeAttributeStyle } from "./edge";
+import { useMeshEdgesVertexAttributeStyle } from "./vertex";
+import { useMeshEdgesVisibilityStyle } from "./visibility";
+import { useMeshEdgesWidthStyle } from "./width";
 
 // Local constants
 
 export function useMeshEdgesStyle() {
-  const meshEdgesCommonStyle = useMeshEdgesCommonStyle()
-  const meshEdgesVisibility = useMeshEdgesVisibilityStyle()
-  const meshEdgesColorStyle = useMeshEdgesColorStyle()
-  const meshEdgesWidthStyle = useMeshEdgesWidthStyle()
-  const meshEdgesVertexAttributeStyle = useMeshEdgesVertexAttributeStyle()
-  const meshEdgesEdgeAttributeStyle = useMeshEdgesEdgeAttributeStyle()
+  const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
+  const meshEdgesVisibility = useMeshEdgesVisibilityStyle();
+  const meshEdgesColorStyle = useMeshEdgesColorStyle();
+  const meshEdgesWidthStyle = useMeshEdgesWidthStyle();
+  const meshEdgesVertexAttributeStyle = useMeshEdgesVertexAttributeStyle();
+  const meshEdgesEdgeAttributeStyle = useMeshEdgesEdgeAttributeStyle();
 
-  async function setMeshEdgesActiveColoring(id, type) {
-    const coloring = meshEdgesCommonStyle.meshEdgesColoring(id)
-    coloring.active = type
+  function setMeshEdgesActiveColoring(id, type) {
+    const coloring = meshEdgesCommonStyle.meshEdgesColoring(id);
+    coloring.active = type;
     console.log(
       setMeshEdgesActiveColoring.name,
       { id },
       meshEdgesCommonStyle.meshEdgesActiveColoring(id),
-    )
+    );
     if (type === "color") {
-      return meshEdgesColorStyle.setMeshEdgesColor(
-        id,
-        meshEdgesColorStyle.meshEdgesColor(id),
-      )
-    } else if (type === "textures") {
-      const textures = meshEdgesTexturesStore.meshEdgesTextures(id)
+      return meshEdgesColorStyle.setMeshEdgesColor(id, meshEdgesColorStyle.meshEdgesColor(id));
+    }
+    if (type === "textures") {
+      const textures = meshEdgesTexturesStore.meshEdgesTextures(id);
       if (textures === undefined) {
-        return Promise.resolve()
+        return Promise.resolve();
       }
-      return meshEdgesTexturesStore.setMeshEdgesTextures(id, textures)
-    } else if (type === "vertex") {
-      const name =
-        meshEdgesVertexAttributeStyle.meshEdgesVertexAttributeName(id)
+      return meshEdgesTexturesStore.setMeshEdgesTextures(id, textures);
+    }
+    if (type === "vertex") {
+      const name = meshEdgesVertexAttributeStyle.meshEdgesVertexAttributeName(id);
       if (name === undefined) {
-        return Promise.resolve()
+        return Promise.resolve();
       }
-      return meshEdgesVertexAttributeStyle.setMeshEdgesVertexAttributeName(
-        id,
-        name,
-      )
-    } else if (type === "edge") {
-      const name = meshEdgesEdgeAttributeStyle.meshEdgesEdgeAttributeName(id)
+      return meshEdgesVertexAttributeStyle.setMeshEdgesVertexAttributeName(id, name);
+    }
+    if (type === "edge") {
+      const name = meshEdgesEdgeAttributeStyle.meshEdgesEdgeAttributeName(id);
       if (name === undefined) {
-        return Promise.resolve()
+        return Promise.resolve();
       }
-      return meshEdgesEdgeAttributeStyle.setMeshEdgesEdgeAttributeName(id, name)
-    } else {
-      throw new Error(`Unknown mesh edges coloring type: ${type}`)
+      return meshEdgesEdgeAttributeStyle.setMeshEdgesEdgeAttributeName(id, name);
     }
+    throw new Error(`Unknown mesh edges coloring type: ${type}`);
   }
 
   function applyMeshEdgesStyle(id) {
     return Promise.all([
-      meshEdgesVisibility.setMeshEdgesVisibility(
-        id,
-        meshEdgesVisibility.meshEdgesVisibility(id),
-      ),
-      meshEdgesWidthStyle.setMeshEdgesWidth(
-        id,
-        meshEdgesWidthStyle.meshEdgesWidth(id),
-      ),
-      setMeshEdgesActiveColoring(
-        id,
-        meshEdgesCommonStyle.meshEdgesActiveColoring(id),
-      ),
-    ])
+      meshEdgesVisibility.setMeshEdgesVisibility(id, meshEdgesVisibility.meshEdgesVisibility(id)),
+      meshEdgesWidthStyle.setMeshEdgesWidth(id, meshEdgesWidthStyle.meshEdgesWidth(id)),
+      setMeshEdgesActiveColoring(id, meshEdgesCommonStyle.meshEdgesActiveColoring(id)),
+    ]);
   }
 
   return {
@@ -84,5 +70,5 @@ export function useMeshEdgesStyle() {
     ...meshEdgesWidthStyle,
     ...meshEdgesVertexAttributeStyle,
     ...meshEdgesEdgeAttributeStyle,
-  }
+  };
 }