@geode/opengeodeweb-front 9.12.0 → 9.12.1-rc.2

package/components/Step.vue

@@ -90,4 +90,14 @@
   function decrement_step() {
     stepper_tree.current_step_index--
   }
+
+  const sortedChips = computed(() => {
+    const chips = steps.value[props.step_index]?.chips || []
+    return [...chips].sort((a, b) =>
+      a.localeCompare(b, undefined, {
+        numeric: true,
+        sensitivity: "base",
+      }),
+    )
+  })
 </script>

package/components/Viewer/Generic/Mesh/EdgesOptions.vue

@@ -28,21 +28,22 @@
   const dataStyleStore = useDataStyleStore()
 
   const visibility = computed({
-    get: () => dataStyleStore.edgesVisibility(id.value),
-    set: (newValue) => dataStyleStore.setEdgesVisibility(id.value, newValue),
+    get: () => dataStyleStore.meshEdgesVisibility(id.value),
+    set: (newValue) =>
+      dataStyleStore.setMeshEdgesVisibility(id.value, newValue),
   })
   const size = computed({
     get: () => dataStyleStore.edgesSize(id.value),
     set: (newValue) => dataStyleStore.setEdgesSize(id.value, newValue),
   })
   const coloring_style_key = computed({
-    get: () => dataStyleStore.edgesActiveColoring(id.value),
+    get: () => dataStyleStore.meshEdgesActiveColoring(id.value),
     set: (newValue) => {
-      dataStyleStore.setEdgesActiveColoring(id.value, newValue)
+      dataStyleStore.setMeshEdgesActiveColoring(id.value, newValue)
     },
   })
   const color = computed({
-    get: () => dataStyleStore.edgesColor(id.value),
-    set: (newValue) => dataStyleStore.setEdgesColor(id.value, newValue),
+    get: () => dataStyleStore.meshEdgesColor(id.value),
+    set: (newValue) => dataStyleStore.setMeshEdgesColor(id.value, newValue),
   })
 </script>

package/components/Viewer/Generic/Mesh/PointsOptions.vue

@@ -49,25 +49,26 @@
   const id = toRef(() => props.itemProps.id)
 
   const visibility = computed({
-    get: () => dataStyleStore.pointsVisibility(id.value),
-    set: (newValue) => dataStyleStore.setPointsVisibility(id.value, newValue),
+    get: () => dataStyleStore.meshPointsVisibility(id.value),
+    set: (newValue) =>
+      dataStyleStore.setMeshPointsVisibility(id.value, newValue),
   })
   const size = computed({
-    get: () => dataStyleStore.pointsSize(id.value),
-    set: (newValue) => dataStyleStore.setPointsSize(id.value, newValue),
+    get: () => dataStyleStore.meshPointsSize(id.value),
+    set: (newValue) => dataStyleStore.setMeshPointsSize(id.value, newValue),
   })
   const coloring_style_key = computed({
-    get: () => dataStyleStore.pointsActiveColoring(id.value),
+    get: () => dataStyleStore.meshPointsActiveColoring(id.value),
     set: (newValue) =>
-      dataStyleStore.setPointsActiveColoring(id.value, newValue),
+      dataStyleStore.setMeshPointsActiveColoring(id.value, newValue),
   })
   const color = computed({
-    get: () => dataStyleStore.pointsColor(id.value),
-    set: (newValue) => dataStyleStore.setPointsColor(id.value, newValue),
+    get: () => dataStyleStore.meshPointsColor(id.value),
+    set: (newValue) => dataStyleStore.setMeshPointsColor(id.value, newValue),
   })
   const vertex_attribute = computed({
-    get: () => dataStyleStore.pointsVertexAttribute(id.value),
+    get: () => dataStyleStore.meshPointsVertexAttribute(id.value),
     set: (newValue) =>
-      dataStyleStore.setPointsVertexAttribute(id.value, newValue),
+      dataStyleStore.setMeshPointsVertexAttribute(id.value, newValue),
   })
 </script>

package/components/Viewer/Generic/Mesh/PolygonsOptions.vue

@@ -32,34 +32,34 @@
   const id = toRef(() => props.itemProps.id)
 
   const visibility = computed({
-    get: () => dataStyleStore.polygonsVisibility(id.value),
-    set: (newValue) => dataStyleStore.setPolygonsVisibility(id.value, newValue),
+    get: () => dataStyleStore.meshPolygonsVisibility(id.value),
+    set: (newValue) =>
+      dataStyleStore.setMeshPolygonsVisibility(id.value, newValue),
   })
   const coloring_style_key = computed({
-    get: () => dataStyleStore.polygonsActiveColoring(id.value),
+    get: () => dataStyleStore.meshPolygonsActiveColoring(id.value),
     set: (newValue) =>
-      dataStyleStore.setPolygonsActiveColoring(id.value, newValue),
+      dataStyleStore.setMeshPolygonsActiveColoring(id.value, newValue),
   })
   const color = computed({
-    get: () => dataStyleStore.polygonsColor(id.value),
-    set: (newValue) => dataStyleStore.setPolygonsColor(id.value, newValue),
+    get: () => dataStyleStore.meshPolygonsColor(id.value),
+    set: (newValue) => dataStyleStore.setMeshPolygonsColor(id.value, newValue),
   })
   const textures = computed({
-    get: () => dataStyleStore.polygonsTextures(id.value),
-    set: (newValue) => dataStyleStore.setPolygonsTextures(id.value, newValue),
+    get: () => dataStyleStore.meshPolygonsTextures(id.value),
+    set: (newValue) =>
+      dataStyleStore.setMeshPolygonsTextures(id.value, newValue),
   })
   const vertex_attribute = computed({
-    get: () => dataStyleStore.polygonsVertexAttribute(id.value),
+    get: () => dataStyleStore.meshPolygonsVertexAttribute(id.value),
     set: (newValue) => {
-      console.log("setPolygonsVertexAttribute", id.value, newValue)
-      dataStyleStore.setPolygonsVertexAttribute(id.value, newValue)
+      dataStyleStore.setMeshPolygonsVertexAttribute(id.value, newValue)
     },
   })
   const polygon_attribute = computed({
-    get: () => dataStyleStore.polygonsPolygonAttribute(id.value),
+    get: () => dataStyleStore.meshPolygonsPolygonAttribute(id.value),
     set: (newValue) => {
-      console.log("setPolygonsPolygonAttribute", id.value, newValue)
-      dataStyleStore.setPolygonsPolygonAttribute(id.value, newValue)
+      dataStyleStore.setMeshPolygonsPolygonAttribute(id.value, newValue)
     },
   })
 </script>

package/components/Viewer/Generic/Mesh/PolyhedraOptions.vue

@@ -32,18 +32,18 @@
   const id = toRef(() => props.itemProps.id)
 
   const visibility = computed({
-    get: () => dataStyleStore.polyhedraVisibility(id.value),
+    get: () => dataStyleStore.meshPolyhedraVisibility(id.value),
     set: (newValue) =>
-      dataStyleStore.setPolyhedraVisibility(id.value, newValue),
+      dataStyleStore.setMeshPolyhedraVisibility(id.value, newValue),
   })
   const coloring_style_key = computed({
-    get: () => dataStyleStore.polyhedraActiveColoring(id.value),
+    get: () => dataStyleStore.meshPolyhedraActiveColoring(id.value),
     set: (newValue) =>
-      dataStyleStore.setPolyhedraActiveColoring(id.value, newValue),
+      dataStyleStore.setMeshPolyhedraActiveColoring(id.value, newValue),
   })
   const color = computed({
-    get: () => dataStyleStore.polyhedraColor(id.value),
-    set: (newValue) => dataStyleStore.setPolyhedraColor(id.value, newValue),
+    get: () => dataStyleStore.meshPolyhedraColor(id.value),
+    set: (newValue) => dataStyleStore.setMeshPolyhedraColor(id.value, newValue),
   })
   const vertex_attribute = computed({
     get: () => dataStyleStore.polyhedraVertexAttribute(id.value),

package/components/Viewer/PointSet/SpecificPointsOptions.vue

@@ -50,25 +50,26 @@
   const id = toRef(() => props.itemProps.id)
 
   const visibility = computed({
-    get: () => dataStyleStore.pointsVisibility(id.value),
-    set: (newValue) => dataStyleStore.setPointsVisibility(id.value, newValue),
+    get: () => dataStyleStore.meshPointsVisibility(id.value),
+    set: (newValue) =>
+      dataStyleStore.setMeshPointsVisibility(id.value, newValue),
   })
   const size = computed({
-    get: () => dataStyleStore.pointsSize(id.value),
-    set: (newValue) => dataStyleStore.setPointsSize(id.value, newValue),
+    get: () => dataStyleStore.meshPointsSize(id.value),
+    set: (newValue) => dataStyleStore.setMeshPointsSize(id.value, newValue),
   })
   const coloring_style_key = computed({
-    get: () => dataStyleStore.pointsActiveColoring(id.value),
+    get: () => dataStyleStore.meshPointsActiveColoring(id.value),
     set: (newValue) =>
-      dataStyleStore.setPointsActiveColoring(id.value, newValue),
+      dataStyleStore.setMeshPointsActiveColoring(id.value, newValue),
   })
   const color = computed({
-    get: () => dataStyleStore.pointsColor(id.value),
-    set: (newValue) => dataStyleStore.setPointsColor(id.value, newValue),
+    get: () => dataStyleStore.meshPointsColor(id.value),
+    set: (newValue) => dataStyleStore.setMeshPointsColor(id.value, newValue),
   })
   const vertex_attribute = computed({
-    get: () => dataStyleStore.pointsVertexAttribute(id.value),
+    get: () => dataStyleStore.meshPointsVertexAttribute(id.value),
     set: (newValue) =>
-      dataStyleStore.setPointsVertexAttribute(id.value, newValue),
+      dataStyleStore.setMeshPointsVertexAttribute(id.value, newValue),
   })
 </script>

package/components/Viewer/Tree/ObjectTree.vue

@@ -9,7 +9,7 @@
     >
       <div class="scrollable-wrapper">
         <v-sheet
-          style="max-height: calc(90vh)"
+          style="max-height: calc(85vh)"
           class="transparent-treeview scrollbar-hover"
         >
           <v-row v-if="treeviewStore.items.length > 0">

package/composables/api_fetch.js

@@ -12,10 +12,8 @@ export function api_fetch(
   const { valid, error } = validate_schema(schema, body)
 
   if (!valid) {
-    if (process.env.NODE_ENV === "development") {
+    if (process.env.NODE_ENV !== "production") {
       console.log("Bad request", error, schema, params)
-      console.log("schema", schema)
-      console.log("params", params)
     }
     feedback_store.add_error(400, schema.$id, "Bad request", error)
     throw new Error(schema.$id.concat(": ", error))

package/composables/viewer_call.js

@@ -8,10 +8,8 @@ export function viewer_call(
   const { valid, error } = validate_schema(schema, params)
 
   if (!valid) {
-    if (process.env.NODE_ENV === "development") {
+    if (process.env.NODE_ENV !== "production") {
       console.log("Bad request", error, schema, params)
-      console.log("schema", schema)
-      console.log("params", params)
     }
     feedback_store.add_error(400, schema.$id, "Bad request", error)
     throw new Error(schema.$id.concat(": "))

package/internal_stores/data_style_state.js

@@ -3,7 +3,7 @@ import { reactive, computed } from "vue"
 export default function useDataStyleState() {
   const styles = reactive({})
 
-  const objectVisibility = computed(() => (id) => styles[id]?.visibility)
+  const objectVisibility = computed(() => (id) => styles[id].visibility)
   const selectedObjects = computed(() => {
     const selection = []
     for (const [id, value] of Object.entries(styles)) {
@@ -17,5 +17,6 @@ export default function useDataStyleState() {
   function getStyle(id) {
     return styles[id]
   }
+
   return { getStyle, styles, objectVisibility, selectedObjects }
 }

package/internal_stores/mesh/edges.js

@@ -1,40 +1,43 @@
+// Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 const mesh_edges_schemas = viewer_schemas.opengeodeweb_viewer.mesh.edges
 
 export function useMeshEdgesStyle() {
   const dataStyleStore = useDataStyleStore()
 
-  function edgesStyle(id) {
+  function meshEdgesStyle(id) {
     return dataStyleStore.getStyle(id).edges
   }
 
-  function edgesVisibility(id) {
-    return edgesStyle(id).visibility
+  function meshEdgesVisibility(id) {
+    return meshEdgesStyle(id).visibility
   }
-  function setEdgesVisibility(id, visibility) {
-    const edges_style = edgesStyle(id)
+  function setMeshEdgesVisibility(id, visibility) {
+    const mesh_edges_style = meshEdgesStyle(id)
     return viewer_call(
       { schema: mesh_edges_schemas.visibility, params: { id, visibility } },
       {
         response_function: () => {
-          edges_style.visibility = visibility
-          console.log(`${setEdgesVisibility.name} ${id} ${edgesVisibility(id)}`)
+          mesh_edges_style.visibility = visibility
+          console.log(
+            `${setMeshEdgesVisibility.name} ${id} ${meshEdgesVisibility(id)}`,
+          )
         },
       },
     )
   }
 
-  function edgesActiveColoring(id) {
-    return edgesStyle(id).coloring.active
+  function meshEdgesActiveColoring(id) {
+    return meshEdgesStyle(id).coloring.active
   }
-  function setEdgesActiveColoring(id, type) {
-    const coloring = edgesStyle(id).coloring
+  function setMeshEdgesActiveColoring(id, type) {
+    const coloring = meshEdgesStyle(id).coloring
     coloring.active = type
     console.log(
-      `${setEdgesActiveColoring.name} ${id} ${edgesActiveColoring(id)}`,
+      `${setMeshEdgesActiveColoring.name} ${id} ${meshEdgesActiveColoring(id)}`,
     )
     if (type === "color") {
-      return setEdgesColor(id, coloring.color)
+      return setMeshEdgesColor(id, coloring.color)
       // } else if (type == "vertex" && coloring.vertex !== null) {
       //   return setEdgesVertexAttribute(id, coloring.vertex)
       // } else if (type == "edges" && coloring.edges !== null) {
@@ -42,57 +45,57 @@ export function useMeshEdgesStyle() {
     } else throw new Error("Unknown edges coloring type: " + type)
   }
 
-  function edgesColor(id) {
-    return edgesStyle(id).coloring.color
+  function meshEdgesColor(id) {
+    return meshEdgesStyle(id).coloring.color
   }
-  function setEdgesColor(id, color) {
-    const coloring_style = edgesStyle(id).coloring
+  function setMeshEdgesColor(id, color) {
+    const coloring_style = meshEdgesStyle(id).coloring
     return viewer_call(
       { schema: mesh_edges_schemas.color, params: { id, color } },
       {
         response_function: () => {
           coloring_style.color = color
           console.log(
-            `${setEdgesColor.name} ${id} ${JSON.stringify(edgesColor(id))}`,
+            `${setMeshEdgesColor.name} ${id} ${JSON.stringify(meshEdgesColor(id))}`,
           )
         },
       },
     )
   }
 
-  function edgesWidth(id) {
-    return edgesStyle(id).size
+  function meshEdgesWidth(id) {
+    return meshEdgesStyle(id).size
   }
-  function setEdgesWidth(id, width) {
-    const edges_style = edgesStyle(id)
+  function setMeshEdgesWidth(id, width) {
+    const edges_style = meshEdgesStyle(id)
     return viewer_call(
       { schema: mesh_edges_schemas.width, params: { id, width } },
       {
         response_function: () => {
           edges_style.width = width
-          console.log(`${setEdgesWidth.name} ${id} ${edgesWidth(id)}`)
+          console.log(`${setMeshEdgesWidth.name} ${id} ${meshEdgesWidth(id)}`)
         },
       },
     )
   }
 
-  function applyEdgesStyle(id, style) {
+  function applyMeshEdgesStyle(id, style) {
     return Promise.all([
-      setEdgesVisibility(id, style.visibility),
-      setEdgesActiveColoring(id, style.coloring.active),
-      // setEdgesWidth(id, style.width);
+      setMeshEdgesVisibility(id, style.visibility),
+      setMeshEdgesActiveColoring(id, style.coloring.active),
+      // setMeshEdgesWidth(id, style.width);
     ])
   }
 
   return {
-    applyEdgesStyle,
-    edgesActiveColoring,
-    edgesColor,
-    edgesVisibility,
-    edgesWidth,
-    setEdgesActiveColoring,
-    setEdgesColor,
-    setEdgesVisibility,
-    setEdgesWidth,
+    applyMeshEdgesStyle,
+    meshEdgesActiveColoring,
+    meshEdgesColor,
+    meshEdgesVisibility,
+    meshEdgesWidth,
+    setMeshEdgesActiveColoring,
+    setMeshEdgesColor,
+    setMeshEdgesVisibility,
+    setMeshEdgesWidth,
   }
 }

package/internal_stores/mesh/index.js

@@ -1,4 +1,7 @@
+// Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
 import { useMeshPointsStyle } from "./points.js"
 import { useMeshEdgesStyle } from "./edges.js"
 import { useMeshPolygonsStyle } from "./polygons.js"
@@ -8,8 +11,8 @@ export default function useMeshStyle() {
   const dataStyleStore = useDataStyleStore()
   const pointsStyleStore = useMeshPointsStyle()
   const edgesStyleStore = useMeshEdgesStyle()
-  const polygonsStyleStore = useMeshPolygonsStyle()
-  const polyhedraStyleStore = useMeshPolyhedraStyle()
+  const meshPolygonsStyleStore = useMeshPolygonsStyle()
+  const meshPolyhedraStyleStore = useMeshPolyhedraStyle()
   const hybridViewerStore = useHybridViewerStore()
 
   function meshVisibility(id) {
@@ -38,15 +41,17 @@ export default function useMeshStyle() {
       if (key == "visibility") {
         promise_array.push(setMeshVisibility(id, value))
       } else if (key == "points") {
-        promise_array.push(pointsStyleStore.applyPointsStyle(id, value))
+        promise_array.push(pointsStyleStore.applyMeshPointsStyle(id, value))
       } else if (key == "edges") {
-        promise_array.push(edgesStyleStore.applyEdgesStyle(id, value))
+        promise_array.push(edgesStyleStore.applyMeshEdgesStyle(id, value))
       } else if (key == "polygons") {
-        promise_array.push(polygonsStyleStore.applyPolygonsStyle(id, value))
+        promise_array.push(
+          meshPolygonsStyleStore.applyMeshPolygonsStyle(id, value),
+        )
       } else if (key == "polyhedra") {
-        promise_array.push(polyhedraStyleStore.applyPolyhedraStyle(id, value))
-      } else {
-        throw new Error("Unknown key: " + key)
+        promise_array.push(
+          meshPolyhedraStyleStore.applyMeshPolyhedraStyle(id, value),
+        )
       }
     }
     return promise_array

package/internal_stores/mesh/points.js

@@ -2,132 +2,119 @@ import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schem
 const mesh_points_schemas = viewer_schemas.opengeodeweb_viewer.mesh.points
 
 export function useMeshPointsStyle() {
-  /** State **/
   const dataStyleStore = useDataStyleStore()
 
-  /** Getters **/
-  function pointsVisibility(id) {
-    return dataStyleStore.styles[id].points.visibility
-  }
-  function pointsActiveColoring(id) {
-    return dataStyleStore.styles[id].points.coloring.active
-  }
-  function pointsColor(id) {
-    return dataStyleStore.styles[id].points.coloring.color
-  }
-  function pointsVertexAttribute(id) {
-    return dataStyleStore.styles[id].points.coloring.vertex
-  }
-  function pointsSize(id) {
-    return dataStyleStore.styles[id].points.size
+  function meshPointsStyle(id) {
+    return dataStyleStore.getStyle(id).points
   }
 
-  /** Actions **/
-  function setPointsVisibility(id, visibility) {
+  function meshPointsVisibility(id) {
+    return meshPointsStyle(id).visibility
+  }
+  function setMeshPointsVisibility(id, visibility) {
+    const points_style = meshPointsStyle(id)
     return viewer_call(
-      {
-        schema: mesh_points_schemas.visibility,
-        params: { id, visibility },
-      },
+      { schema: mesh_points_schemas.visibility, params: { id, visibility } },
       {
         response_function: () => {
-          dataStyleStore.styles[id].points.visibility = visibility
+          points_style.visibility = visibility
           console.log(
-            "setPointsVisibility",
-            dataStyleStore.styles[id].points.visibility,
+            `${setMeshPointsVisibility.name} ${id} ${meshPointsVisibility(id)}`,
           )
         },
       },
     )
   }
 
-  function setPointsColor(id, color) {
+  function meshPointsActiveColoring(id) {
+    return meshPointsStyle(id).coloring.active
+  }
+  function setMeshPointsActiveColoring(id, type) {
+    const coloring = meshPointsStyle(id).coloring
+    coloring.active = type
+    console.log(
+      `${setMeshPointsActiveColoring.name} ${id} ${meshPointsActiveColoring(id)}`,
+    )
+    if (type == "color") {
+      return dataStyleStore.setMeshPointsColor(id, coloring.color)
+    } else if (type == "vertex" && coloring.vertex !== null) {
+      return dataStyleStore.setMeshPointsVertexAttribute(id, coloring.vertex)
+    } else throw new Error("Unknown points coloring type: " + type)
+  }
+
+  function meshPointsColor(id) {
+    return meshPointsStyle(id).coloring.color
+  }
+  function setMeshPointsColor(id, color) {
+    const coloring_style = meshPointsStyle(id).coloring
     return viewer_call(
-      {
-        schema: viewer_schemas.opengeodeweb_viewer.mesh.points.color,
-        params: { id, color },
-      },
+      { schema: mesh_points_schemas.color, params: { id, color } },
       {
         response_function: () => {
-          dataStyleStore.styles[id].points.coloring.color = color
+          coloring_style.color = color
           console.log(
-            "setPointsColor",
-            dataStyleStore.styles[id].points.coloring.color,
+            `${setMeshPointsColor.name} ${id} ${JSON.stringify(meshPointsColor(id))}`,
           )
         },
       },
     )
   }
-  function setPointsVertexAttribute(id, vertex_attribute) {
+  function meshPointsVertexAttribute(id) {
+    return meshPointsStyle(id).coloring.vertex
+  }
+  function setMeshPointsVertexAttribute(id, vertex_attribute) {
+    const coloring_style = meshPointsStyle(id).coloring
     return viewer_call(
       {
-        schema: viewer_schemas.opengeodeweb_viewer.mesh.points.vertex_attribute,
+        schema: mesh_points_schemas.vertex_attribute,
         params: { id, ...vertex_attribute },
       },
       {
         response_function: () => {
-          dataStyleStore.styles[id].points.coloring.vertex = vertex_attribute
+          coloring_style.vertex = vertex_attribute
           console.log(
-            "setPointsVertexAttribute",
-            dataStyleStore.styles[id].points.coloring.vertex,
+            `${setMeshPointsVertexAttribute.name} ${id} ${meshPointsVertexAttribute(id)}`,
           )
         },
       },
     )
   }
-  function setPointsSize(id, size) {
+
+  function meshPointsSize(id) {
+    return meshPointsStyle(id).size
+  }
+  function setMeshPointsSize(id, size) {
+    const points_style = meshPointsStyle(id)
     return viewer_call(
-      {
-        schema: viewer_schemas.opengeodeweb_viewer.mesh.points.size,
-        params: { id, size },
-      },
+      { schema: mesh_points_schemas.size, params: { id, size } },
       {
         response_function: () => {
-          dataStyleStore.styles[id].points.size = size
-          console.log("setPointsSize", dataStyleStore.styles[id].points.size)
+          points_style.size = size
+          console.log(`${setMeshPointsSize.name} ${id} ${meshPointsSize(id)}`)
         },
       },
     )
   }
 
-  function setPointsActiveColoring(id, type) {
-    if (type == "color")
-      dataStyleStore.setPointsColor(
-        id,
-        dataStyleStore.styles[id].points.coloring.color,
-      )
-    else if (type == "vertex") {
-      const vertex = dataStyleStore.styles[id].points.coloring.vertex
-      if (vertex !== null) dataStyleStore.setPointsVertexAttribute(id, vertex)
-    } else throw new Error("Unknown edges coloring type: " + type)
-    dataStyleStore.styles[id].points.coloring.active = type
-    console.log(
-      "setPointsActiveColoring",
-      dataStyleStore.styles[id].points.coloring.active,
-    )
-  }
-
-  function applyPointsStyle(id, style) {
+  function applyMeshPointsStyle(id, style) {
     return Promise.all([
-      setPointsVisibility(id, style.visibility),
-      setPointsActiveColoring(id, style.coloring.active),
-      setPointsSize(id, style.size),
+      setMeshPointsVisibility(id, style.visibility),
+      setMeshPointsActiveColoring(id, style.coloring.active),
+      setMeshPointsSize(id, style.size),
     ])
   }
 
   return {
-    pointsVisibility,
-    pointsActiveColoring,
-    pointsColor,
-    pointsVertexAttribute,
-    pointsSize,
-    setPointsVisibility,
-    setPointsActiveColoring,
-    setPointsColor,
-    setPointsVertexAttribute,
-    setPointsSize,
-    applyPointsStyle,
+    meshPointsVisibility,
+    meshPointsActiveColoring,
+    meshPointsColor,
+    meshPointsVertexAttribute,
+    meshPointsSize,
+    setMeshPointsVisibility,
+    setMeshPointsActiveColoring,
+    setMeshPointsColor,
+    setMeshPointsVertexAttribute,
+    setMeshPointsSize,
+    applyMeshPointsStyle,
   }
 }
-
-export default useMeshPointsStyle