@geode/opengeodeweb-front 10.2.1 → 10.3.0

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

@@ -0,0 +1,153 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap"
+import { useMeshCellsCommonStyle } from "./common"
+
+// Local constants
+const meshCellsVertexAttributeSchemas =
+  viewer_schemas.opengeodeweb_viewer.mesh.cells.attribute.vertex
+
+export function useMeshCellsVertexAttributeStyle() {
+  const viewerStore = useViewerStore()
+  const meshCellsCommonStyle = useMeshCellsCommonStyle()
+
+  function meshCellsVertexAttribute(id) {
+    return meshCellsCommonStyle.meshCellsColoring(id).vertex
+  }
+
+  async function updateMeshCellsVertexAttribute(id) {
+    const name = meshCellsVertexAttributeName(id)
+    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name)
+    await meshCellsVertexAttributeRange(
+      id,
+      storedConfig.minimum,
+      storedConfig.maximum,
+    )
+    await meshCellsVertexAttributeColorMap(id, storedConfig.colorMap)
+  }
+
+  function meshCellsVertexAttributeStoredConfig(id, name) {
+    const storedConfigs = meshCellsVertexAttribute(id).storedConfigs
+    if (name in storedConfigs) {
+      return storedConfigs[name]
+    }
+    return setMeshCellsVertexAttributeStoredConfig(id, name, {
+      minimum: 0,
+      maximum: 1,
+      colorMap: "Cool to Warm",
+    })
+  }
+
+  function setMeshCellsVertexAttributeStoredConfig(
+    id,
+    name,
+    { minimum, maximum, colorMap },
+  ) {
+    const storedConfigs = meshCellsVertexAttribute(id).storedConfigs
+    storedConfigs[name] = { minimum, maximum, colorMap }
+    return storedConfigs[name]
+  }
+
+  function meshCellsVertexAttributeName(id) {
+    console.log(
+      meshCellsVertexAttributeName.name,
+      { id },
+      meshCellsVertexAttribute(id),
+    )
+    return meshCellsVertexAttribute(id).name
+  }
+  function setMeshCellsVertexAttributeName(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, colorMap } =
+            meshCellsVertexAttributeStoredConfig(id, name)
+          await setMeshCellsVertexAttributeRange(id, minimum, maximum)
+          await setMeshCellsVertexAttributeColorMap(id, colorMap)
+          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]
+  }
+  function setMeshCellsVertexAttributeRange(id, minimum, maximum) {
+    const name = meshCellsVertexAttributeName(id)
+    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name)
+    return viewerStore.request(
+      meshCellsVertexAttributeSchemas.scalar_range,
+      { id, minimum, maximum },
+      {
+        response_function: () => {
+          storedConfig.minimum = minimum
+          storedConfig.maximum = maximum
+          console.log(
+            setMeshCellsVertexAttributeRange.name,
+            { id },
+            meshCellsVertexAttributeRange(id),
+          )
+        },
+      },
+    )
+  }
+
+  function meshCellsVertexAttributeColorMap(id) {
+    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 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
+          console.log(
+            setMeshCellsVertexAttributeColorMap.name,
+            { id },
+            meshCellsVertexAttributeColorMap(id),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    meshCellsVertexAttributeName,
+    meshCellsVertexAttributeRange,
+    meshCellsVertexAttributeColorMap,
+    setMeshCellsVertexAttributeName,
+    setMeshCellsVertexAttributeRange,
+    setMeshCellsVertexAttributeColorMap,
+    updateMeshCellsVertexAttribute,
+  }
+}

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

@@ -0,0 +1,40 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshCellsCommonStyle } from "./common"
+
+// Local constants
+const meshCellsVisibilitySchema =
+  viewer_schemas.opengeodeweb_viewer.mesh.cells.visibility
+
+export function useMeshCellsVisibilityStyle() {
+  const viewerStore = useViewerStore()
+  const meshCellsCommonStyle = useMeshCellsCommonStyle()
+
+  function meshCellsVisibility(id) {
+    return meshCellsCommonStyle.meshCellsStyle(id).visibility
+  }
+  function setMeshCellsVisibility(id, visibility) {
+    return viewerStore.request(
+      meshCellsVisibilitySchema,
+      { id, visibility },
+      {
+        response_function: () => {
+          meshCellsCommonStyle.meshCellsStyle(id).visibility = visibility
+          console.log(
+            setMeshCellsVisibility.name,
+            { id },
+            meshCellsVisibility(id),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    meshCellsVisibility,
+    setMeshCellsVisibility,
+  }
+}

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

@@ -0,0 +1,40 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshEdgesCommonStyle } from "./common"
+
+// Local constants
+const meshEdgesColorSchemas =
+  viewer_schemas.opengeodeweb_viewer.mesh.edges.color
+
+export function useMeshEdgesColorStyle() {
+  const viewerStore = useViewerStore()
+  const meshEdgesCommonStyle = useMeshEdgesCommonStyle()
+
+  function meshEdgesColor(id) {
+    return meshEdgesCommonStyle.meshEdgesColoring(id).color
+  }
+  function setMeshEdgesColor(id, color) {
+    return viewerStore.request(
+      meshEdgesColorSchemas,
+      { id, color },
+      {
+        response_function: () => {
+          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

@@ -0,0 +1,23 @@
+import { useDataStyleStateStore } from "../../state"
+
+export function useMeshEdgesCommonStyle() {
+  const dataStyleStateStore = useDataStyleStateStore()
+
+  function meshEdgesStyle(id) {
+    return dataStyleStateStore.getStyle(id).edges
+  }
+
+  function meshEdgesColoring(id) {
+    return meshEdgesStyle(id).coloring
+  }
+
+  function meshEdgesActiveColoring(id) {
+    return meshEdgesColoring(id).active
+  }
+
+  return {
+    meshEdgesStyle,
+    meshEdgesColoring,
+    meshEdgesActiveColoring,
+  }
+}

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

@@ -0,0 +1,141 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap"
+import { useMeshEdgesCommonStyle } from "./common"
+
+// Local constants
+const meshEdgesEdgeAttributeSchemas =
+  viewer_schemas.opengeodeweb_viewer.mesh.edges.attribute.edge
+
+export function useMeshEdgesEdgeAttributeStyle() {
+  const viewerStore = useViewerStore()
+  const meshEdgesCommonStyle = useMeshEdgesCommonStyle()
+
+  function meshEdgesEdgeAttribute(id) {
+    return meshEdgesCommonStyle.meshEdgesColoring(id).edge
+  }
+
+  function meshEdgesEdgeAttributeStoredConfig(id, name) {
+    const storedConfigs = meshEdgesEdgeAttribute(id).storedConfigs
+    if (name in storedConfigs) {
+      return storedConfigs[name]
+    }
+    return setMeshEdgesEdgeAttributeStoredConfig(id, name, {
+      minimum: 0,
+      maximum: 1,
+      colorMap: "Cool to Warm",
+    })
+  }
+
+  function setMeshEdgesEdgeAttributeStoredConfig(
+    id,
+    name,
+    { minimum, maximum, colorMap },
+  ) {
+    const storedConfigs = meshEdgesEdgeAttribute(id).storedConfigs
+    storedConfigs[name] = { minimum, maximum, colorMap }
+    return storedConfigs[name]
+  }
+
+  function meshEdgesEdgeAttributeName(id) {
+    console.log(
+      meshEdgesEdgeAttributeName.name,
+      { id },
+      meshEdgesEdgeAttribute(id),
+    )
+    return meshEdgesEdgeAttribute(id).name
+  }
+  function setMeshEdgesEdgeAttributeName(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, colorMap } =
+          //   meshEdgesEdgeAttributeStoredConfig(id, name)
+          // await setMeshEdgesEdgeAttributeRange(id, minimum, maximum)
+          // await setMeshEdgesEdgeAttributeColorMap(id, colorMap)
+          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]
+  // }
+  // function setMeshEdgesEdgeAttributeRange(id, minimum, maximum) {
+  //   const name = meshEdgesEdgeAttributeName(id)
+  //   const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name)
+  //   return viewerStore.request(
+  //     meshEdgesEdgeAttributeSchemas.scalar_range,
+  //     { id, minimum, maximum },
+  //     {
+  //       response_function: () => {
+  //         storedConfig.minimum = minimum
+  //         storedConfig.maximum = maximum
+  //         console.log(
+  //           setMeshEdgesEdgeAttributeRange.name,
+  //           { id },
+  //           meshEdgesEdgeAttributeRange(id),
+  //         )
+  //       },
+  //     },
+  //   )
+  // }
+
+  // function meshEdgesEdgeAttributeColorMap(id) {
+  //   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 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
+  //         console.log(
+  //           setMeshEdgesEdgeAttributeColorMap.name,
+  //           { id },
+  //           meshEdgesEdgeAttributeColorMap(id),
+  //         )
+  //       },
+  //     },
+  //   )
+  // }
+
+  return {
+    meshEdgesEdgeAttributeName,
+    // meshEdgesEdgeAttributeRange,
+    // meshEdgesEdgeAttributeColorMap,
+    setMeshEdgesEdgeAttributeName,
+    // setMeshEdgesEdgeAttributeRange,
+    // setMeshEdgesEdgeAttributeColorMap,
+  }
+}

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

@@ -0,0 +1,88 @@
+// Third party imports
+
+// Local imports
+import { useMeshEdgesCommonStyle } from "./common"
+import { useMeshEdgesVisibilityStyle } from "./visibility"
+import { useMeshEdgesColorStyle } from "./color"
+import { useMeshEdgesWidthStyle } from "./width"
+import { useMeshEdgesVertexAttributeStyle } from "./vertex"
+import { useMeshEdgesEdgeAttributeStyle } from "./edge"
+
+// Local constants
+
+export function useMeshEdgesStyle() {
+  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
+    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)
+      if (textures === null) {
+        return Promise.resolve()
+      }
+      return meshEdgesTexturesStore.setMeshEdgesTextures(id, textures)
+    } else if (type === "vertex") {
+      const name =
+        meshEdgesVertexAttributeStyle.meshEdgesVertexAttributeName(id)
+      if (name === null) {
+        return Promise.resolve()
+      }
+      return meshEdgesVertexAttributeStyle.setMeshEdgesVertexAttributeName(
+        id,
+        name,
+      )
+    } else if (type === "edge") {
+      const name = meshEdgesEdgeAttributeStyle.meshEdgesEdgeAttributeName(id)
+      if (name === null) {
+        return Promise.resolve()
+      }
+      return meshEdgesEdgeAttributeStyle.setMeshEdgesEdgeAttributeName(id, name)
+    } else {
+      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),
+      ),
+    ])
+  }
+
+  return {
+    setMeshEdgesActiveColoring,
+    applyMeshEdgesStyle,
+    ...meshEdgesCommonStyle,
+    ...meshEdgesVisibility,
+    ...meshEdgesColorStyle,
+    ...meshEdgesWidthStyle,
+    ...meshEdgesVertexAttributeStyle,
+    ...meshEdgesEdgeAttributeStyle,
+  }
+}

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

@@ -0,0 +1,153 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap"
+import { useMeshEdgesCommonStyle } from "./common"
+
+// Local constants
+const meshEdgesVertexAttributeSchemas =
+  viewer_schemas.opengeodeweb_viewer.mesh.edges.attribute.vertex
+
+export function useMeshEdgesVertexAttributeStyle() {
+  const viewerStore = useViewerStore()
+  const meshEdgesCommonStyle = useMeshEdgesCommonStyle()
+
+  function meshEdgesVertexAttribute(id) {
+    return meshEdgesCommonStyle.meshEdgesColoring(id).vertex
+  }
+
+  async function updateMeshEdgesVertexAttribute(id) {
+    const name = meshEdgesVertexAttributeName(id)
+    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name)
+    await meshEdgesVertexAttributeRange(
+      id,
+      storedConfig.minimum,
+      storedConfig.maximum,
+    )
+    await meshEdgesVertexAttributeColorMap(id, storedConfig.colorMap)
+  }
+
+  function meshEdgesVertexAttributeStoredConfig(id, name) {
+    const storedConfigs = meshEdgesVertexAttribute(id).storedConfigs
+    if (name in storedConfigs) {
+      return storedConfigs[name]
+    }
+    return setMeshEdgesVertexAttributeStoredConfig(id, name, {
+      minimum: 0,
+      maximum: 1,
+      colorMap: "Cool to Warm",
+    })
+  }
+
+  function setMeshEdgesVertexAttributeStoredConfig(
+    id,
+    name,
+    { minimum, maximum, colorMap },
+  ) {
+    const storedConfigs = meshEdgesVertexAttribute(id).storedConfigs
+    storedConfigs[name] = { minimum, maximum, colorMap }
+    return storedConfigs[name]
+  }
+
+  function meshEdgesVertexAttributeName(id) {
+    console.log(
+      meshEdgesVertexAttributeName.name,
+      { id },
+      meshEdgesVertexAttribute(id),
+    )
+    return meshEdgesVertexAttribute(id).name
+  }
+  function setMeshEdgesVertexAttributeName(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, colorMap } =
+            meshEdgesVertexAttributeStoredConfig(id, name)
+          await setMeshEdgesVertexAttributeRange(id, minimum, maximum)
+          await setMeshEdgesVertexAttributeColorMap(id, colorMap)
+          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]
+  }
+  function setMeshEdgesVertexAttributeRange(id, minimum, maximum) {
+    const name = meshEdgesVertexAttributeName(id)
+    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name)
+    return viewerStore.request(
+      meshEdgesVertexAttributeSchemas.scalar_range,
+      { id, minimum, maximum },
+      {
+        response_function: () => {
+          storedConfig.minimum = minimum
+          storedConfig.maximum = maximum
+          console.log(
+            setMeshEdgesVertexAttributeRange.name,
+            { id },
+            meshEdgesVertexAttributeRange(id),
+          )
+        },
+      },
+    )
+  }
+
+  function meshEdgesVertexAttributeColorMap(id) {
+    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 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
+          console.log(
+            setMeshEdgesVertexAttributeColorMap.name,
+            { id },
+            meshEdgesVertexAttributeColorMap(id),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    meshEdgesVertexAttributeName,
+    meshEdgesVertexAttributeRange,
+    meshEdgesVertexAttributeColorMap,
+    setMeshEdgesVertexAttributeName,
+    setMeshEdgesVertexAttributeRange,
+    setMeshEdgesVertexAttributeColorMap,
+    updateMeshEdgesVertexAttribute,
+  }
+}

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

@@ -0,0 +1,40 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshEdgesCommonStyle } from "./common"
+
+// Local constants
+const meshEdgesVisibilitySchema =
+  viewer_schemas.opengeodeweb_viewer.mesh.edges.visibility
+
+export function useMeshEdgesVisibilityStyle() {
+  const viewerStore = useViewerStore()
+  const meshEdgesCommonStyle = useMeshEdgesCommonStyle()
+
+  function meshEdgesVisibility(id) {
+    return meshEdgesCommonStyle.meshEdgesStyle(id).visibility
+  }
+  function setMeshEdgesVisibility(id, visibility) {
+    return viewerStore.request(
+      meshEdgesVisibilitySchema,
+      { id, visibility },
+      {
+        response_function: () => {
+          meshEdgesCommonStyle.meshEdgesStyle(id).visibility = visibility
+          console.log(
+            setMeshEdgesVisibility.name,
+            { id },
+            meshEdgesVisibility(id),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    meshEdgesVisibility,
+    setMeshEdgesVisibility,
+  }
+}