@geode/opengeodeweb-front 10.2.1 → 10.3.0

package/internal/stores/mesh/polygons.js

@@ -1,181 +0,0 @@
-// Third party imports
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
-
-// Local imports
-import { useDataStyleStateStore } from "../data_style_state"
-import { useViewerStore } from "@ogw_front/stores/viewer"
-
-// Local constants
-const mesh_polygons_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polygons
-
-export function useMeshPolygonsStyle() {
-  const dataStyleStateStore = useDataStyleStateStore()
-  const viewerStore = useViewerStore()
-
-  function meshPolygonsStyle(id) {
-    return dataStyleStateStore.getStyle(id).polygons
-  }
-
-  function meshPolygonsVisibility(id) {
-    return meshPolygonsStyle(id).visibility
-  }
-  function setMeshPolygonsVisibility(id, visibility) {
-    const polygons_style = meshPolygonsStyle(id)
-    return viewerStore.request(
-      mesh_polygons_schemas.visibility,
-      { id, visibility },
-      {
-        response_function: () => {
-          polygons_style.visibility = visibility
-          console.log(
-            setMeshPolygonsVisibility.name,
-            { id },
-            meshPolygonsVisibility(id),
-          )
-        },
-      },
-    )
-  }
-
-  function meshPolygonsColor(id) {
-    return meshPolygonsStyle(id).coloring.color
-  }
-  function setMeshPolygonsColor(id, color) {
-    const coloring_style = meshPolygonsStyle(id).coloring
-    return viewerStore.request(
-      mesh_polygons_schemas.color,
-      { id, color },
-      {
-        response_function: () => {
-          coloring_style.color = color
-          console.log(
-            setMeshPolygonsColor.name,
-            { id },
-            JSON.stringify(meshPolygonsColor(id)),
-          )
-        },
-      },
-    )
-  }
-
-  function meshPolygonsTextures(id) {
-    return meshPolygonsStyle(id).coloring.textures
-  }
-  function setMeshPolygonsTextures(id, textures) {
-    const coloring_style = meshPolygonsStyle(id).coloring
-    return viewerStore.request(
-      mesh_polygons_schemas.apply_textures,
-      { id, textures },
-      {
-        response_function: () => {
-          coloring_style.textures = textures
-          console.log(
-            setMeshPolygonsTextures.name,
-            { id },
-            meshPolygonsTextures(id),
-          )
-        },
-      },
-    )
-  }
-
-  function meshPolygonsVertexAttribute(id) {
-    return meshPolygonsStyle(id).coloring.vertex
-  }
-
-  function setMeshPolygonsVertexAttribute(id, vertex_attribute) {
-    const coloring_style = meshPolygonsStyle(id).coloring
-    return viewerStore.request(
-      mesh_polygons_schemas.vertex_attribute,
-      { id, ...vertex_attribute },
-      {
-        response_function: () => {
-          coloring_style.vertex = vertex_attribute
-          console.log(
-            setMeshPolygonsVertexAttribute.name,
-            { id },
-            meshPolygonsVertexAttribute(id),
-          )
-        },
-      },
-    )
-  }
-
-  function meshPolygonsPolygonAttribute(id) {
-    return meshPolygonsStyle(id).coloring.polygon
-  }
-  function setMeshPolygonsPolygonAttribute(id, polygon_attribute) {
-    const coloring_style = meshPolygonsStyle(id).coloring
-    return viewerStore.request(
-      mesh_polygons_schemas.polygon_attribute,
-      { id, ...polygon_attribute },
-      {
-        response_function: () => {
-          coloring_style.polygon = polygon_attribute
-          console.log(
-            setMeshPolygonsPolygonAttribute.name,
-            { id },
-            meshPolygonsPolygonAttribute(id),
-          )
-        },
-      },
-    )
-  }
-
-  function meshPolygonsActiveColoring(id) {
-    return meshPolygonsStyle(id).coloring.active
-  }
-  function setMeshPolygonsActiveColoring(id, type) {
-    const coloring = meshPolygonsStyle(id).coloring
-    coloring.active = type
-    console.log(
-      setMeshPolygonsActiveColoring.name,
-      { id },
-      meshPolygonsActiveColoring(id),
-    )
-    if (type === "color") {
-      return setMeshPolygonsColor(id, coloring.color)
-    } else if (type === "textures") {
-      if (coloring.textures === null) {
-        throw new Error("Textures not set")
-      }
-      return setMeshPolygonsTextures(id, coloring.textures)
-    } else if (type === "vertex") {
-      if (coloring.vertex === null) {
-        throw new Error("Vertex attribute not set")
-      }
-      return setMeshPolygonsVertexAttribute(id, coloring.vertex)
-    } else if (type === "polygon") {
-      if (coloring.polygon === null) {
-        throw new Error("Polygon attribute not set")
-      }
-      return setMeshPolygonsPolygonAttribute(id, coloring.polygon)
-    } else {
-      throw new Error("Unknown mesh polygons coloring type: " + type)
-    }
-  }
-
-  function applyMeshPolygonsStyle(id) {
-    const style = meshPolygonsStyle(id)
-    return Promise.all([
-      setMeshPolygonsVisibility(id, style.visibility),
-      setMeshPolygonsActiveColoring(id, style.coloring.active),
-    ])
-  }
-
-  return {
-    meshPolygonsVisibility,
-    meshPolygonsActiveColoring,
-    meshPolygonsColor,
-    meshPolygonsTextures,
-    meshPolygonsPolygonAttribute,
-    meshPolygonsVertexAttribute,
-    setMeshPolygonsVisibility,
-    setMeshPolygonsActiveColoring,
-    setMeshPolygonsColor,
-    setMeshPolygonsTextures,
-    setMeshPolygonsVertexAttribute,
-    setMeshPolygonsPolygonAttribute,
-    applyMeshPolygonsStyle,
-  }
-}

package/internal/stores/mesh/polyhedra.js

@@ -1,151 +0,0 @@
-// Third party imports
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
-
-// Local imports
-import { useDataStyleStateStore } from "../data_style_state"
-import { useViewerStore } from "@ogw_front/stores/viewer"
-
-// Local constants
-const mesh_polyhedra_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra
-
-export function useMeshPolyhedraStyle() {
-  const dataStyleStateStore = useDataStyleStateStore()
-  const viewerStore = useViewerStore()
-
-  function meshPolyhedraStyle(id) {
-    return dataStyleStateStore.getStyle(id).polyhedra
-  }
-
-  function meshPolyhedraVisibility(id) {
-    return meshPolyhedraStyle(id).visibility
-  }
-  function setMeshPolyhedraVisibility(id, visibility) {
-    const polyhedra_style = meshPolyhedraStyle(id)
-    return viewerStore.request(
-      mesh_polyhedra_schemas.visibility,
-      { id, visibility },
-      {
-        response_function: () => {
-          polyhedra_style.visibility = visibility
-          console.log(
-            setMeshPolyhedraVisibility.name,
-            { id },
-            meshPolyhedraVisibility(id),
-          )
-        },
-      },
-    )
-  }
-  function meshPolyhedraActiveColoring(id) {
-    return meshPolyhedraStyle(id).coloring.active
-  }
-  function setMeshPolyhedraActiveColoring(id, type) {
-    const coloring = meshPolyhedraStyle(id).coloring
-    coloring.active = type
-    console.log(
-      setMeshPolyhedraActiveColoring.name,
-      { id },
-      meshPolyhedraActiveColoring(id),
-    )
-    if (type === "color") {
-      return setMeshPolyhedraColor(id, coloring.color)
-    } else if (type === "vertex") {
-      if (coloring.vertex === null) {
-        throw new Error("Vertex attribute not set")
-      }
-      return setMeshPolyhedraVertexAttribute(id, coloring.vertex)
-    } else if (type === "polyhedron") {
-      if (coloring.polyhedron === null) {
-        throw new Error("Polyhedron attribute not set")
-      }
-      return setMeshPolyhedraPolyhedronAttribute(id, coloring.polyhedron)
-    } else {
-      throw new Error("Unknown mesh polyhedra coloring type: " + type)
-    }
-  }
-
-  function meshPolyhedraColor(id) {
-    return meshPolyhedraStyle(id).coloring.color
-  }
-  function setMeshPolyhedraColor(id, color) {
-    const coloring = meshPolyhedraStyle(id).coloring
-    return viewerStore.request(
-      mesh_polyhedra_schemas.color,
-      { id, color },
-      {
-        response_function: () => {
-          coloring.color = color
-          console.log(
-            setMeshPolyhedraColor.name,
-            { id },
-            JSON.stringify(meshPolyhedraColor(id)),
-          )
-        },
-      },
-    )
-  }
-
-  function meshPolyhedraVertexAttribute(id) {
-    return meshPolyhedraStyle(id).coloring.vertex
-  }
-  function setMeshPolyhedraVertexAttribute(id, vertex_attribute) {
-    const coloring_style = meshPolyhedraStyle(id).coloring
-    return viewerStore.request(
-      mesh_polyhedra_schemas.vertex_attribute,
-      { id, ...vertex_attribute },
-      {
-        response_function: () => {
-          coloring_style.vertex = vertex_attribute
-          console.log(
-            setMeshPolyhedraVertexAttribute.name,
-            { id },
-            meshPolyhedraVertexAttribute(id),
-          )
-        },
-      },
-    )
-  }
-
-  function meshPolyhedraPolyhedronAttribute(id) {
-    return meshPolyhedraStyle(id).coloring.polyhedron
-  }
-  function setMeshPolyhedraPolyhedronAttribute(id, polyhedron_attribute) {
-    const coloring = meshPolyhedraStyle(id).coloring
-    return viewerStore.request(
-      mesh_polyhedra_schemas.polyhedron_attribute,
-      { id, ...polyhedron_attribute },
-      {
-        response_function: () => {
-          coloring.polyhedron = polyhedron_attribute
-          console.log(
-            setMeshPolyhedraPolyhedronAttribute.name,
-            { id },
-            meshPolyhedraPolyhedronAttribute(id),
-          )
-        },
-      },
-    )
-  }
-
-  function applyMeshPolyhedraStyle(id) {
-    const style = meshPolyhedraStyle(id)
-    return Promise.all([
-      setMeshPolyhedraVisibility(id, style.visibility),
-      setMeshPolyhedraActiveColoring(id, style.coloring.active),
-    ])
-  }
-
-  return {
-    applyMeshPolyhedraStyle,
-    meshPolyhedraActiveColoring,
-    meshPolyhedraColor,
-    meshPolyhedraVertexAttribute,
-    meshPolyhedraVisibility,
-    meshPolyhedraPolyhedronAttribute,
-    setMeshPolyhedraActiveColoring,
-    setMeshPolyhedraColor,
-    setMeshPolyhedraPolyhedronAttribute,
-    setMeshPolyhedraVertexAttribute,
-    setMeshPolyhedraVisibility,
-  }
-}