@geode/opengeodeweb-front 10.2.1 → 10.3.0

package/tests/integration/stores/data_style/mesh/polyhedra.nuxt.test.js

@@ -86,28 +86,22 @@ describe("Mesh polyhedra", () => {
         {
           name: "vertex",
           function: () =>
-            dataStyleStore.setMeshPolyhedraVertexAttribute(
+            dataStyleStore.setMeshPolyhedraVertexAttributeName(
               id,
-              vertex_attribute,
+              vertex_attribute.name,
             ),
         },
         {
           name: "polyhedron",
           function: () =>
-            dataStyleStore.setMeshPolyhedraPolyhedronAttribute(
+            dataStyleStore.setMeshPolyhedraPolyhedronAttributeName(
               id,
-              polyhedron_attribute,
+              polyhedron_attribute.name,
             ),
         },
       ]
       for (let i = 0; i < coloringTypes.length; i++) {
         if (coloringTypes[i].function) {
-          expect(() =>
-            dataStyleStore.setMeshPolyhedraActiveColoring(
-              id,
-              coloringTypes[i].name,
-            ),
-          ).toThrowError()
           await coloringTypes[i].function()
         }
         const result = dataStyleStore.setMeshPolyhedraActiveColoring(
@@ -129,16 +123,19 @@ describe("Mesh polyhedra", () => {
     const viewerStore = useViewerStore()
 
     const spy = vi.spyOn(viewerStore, "request")
-    await dataStyleStore.setMeshPolyhedraVertexAttribute(id, vertex_attribute)
+    await dataStyleStore.setMeshPolyhedraVertexAttributeName(
+      id,
+      vertex_attribute.name,
+    )
     expect(spy).toHaveBeenCalledWith(
-      mesh_polyhedra_schemas.vertex_attribute,
+      mesh_polyhedra_schemas.attribute.vertex.name,
       { id, ...vertex_attribute },
       {
         response_function: expect.any(Function),
       },
     )
-    expect(dataStyleStore.meshPolyhedraVertexAttribute(id)).toStrictEqual(
-      vertex_attribute,
+    expect(dataStyleStore.meshPolyhedraVertexAttributeName(id)).toBe(
+      vertex_attribute.name,
     )
     expect(viewerStore.status).toBe(Status.CONNECTED)
   })
@@ -148,19 +145,19 @@ describe("Mesh polyhedra", () => {
     const viewerStore = useViewerStore()
 
     const spy = vi.spyOn(viewerStore, "request")
-    await dataStyleStore.setMeshPolyhedraPolyhedronAttribute(
+    await dataStyleStore.setMeshPolyhedraPolyhedronAttributeName(
       id,
-      polyhedron_attribute,
+      polyhedron_attribute.name,
     )
     expect(spy).toHaveBeenCalledWith(
-      mesh_polyhedra_schemas.polyhedron_attribute,
+      mesh_polyhedra_schemas.attribute.polyhedron.name,
       { id, ...polyhedron_attribute },
       {
         response_function: expect.any(Function),
       },
     )
-    expect(dataStyleStore.meshPolyhedraPolyhedronAttribute(id)).toStrictEqual(
-      polyhedron_attribute,
+    expect(dataStyleStore.meshPolyhedraPolyhedronAttributeName(id)).toBe(
+      polyhedron_attribute.name,
     )
     expect(viewerStore.status).toBe(Status.CONNECTED)
   })

package/tests/vitest.config.js

@@ -6,11 +6,13 @@ const globalRetry = process.env.CI ? 3 : 0
 
 export default defineConfig({
   test: {
+    globals: true,
     setupFiles: [path.resolve(__dirname, "./setup_indexeddb.js")],
     projects: [
       await defineVitestProject({
         test: {
           name: "unit",
+          globals: true,
           include: ["tests/unit/**/*.test.js"],
           environment: "nuxt",
           setupFiles: [path.resolve(__dirname, "./setup_indexeddb.js")],
@@ -25,6 +27,7 @@ export default defineConfig({
       await defineVitestProject({
         test: {
           name: "integration",
+          globals: true,
           include: ["tests/integration/**/*.test.js"],
           environment: "nuxt",
           fileParallelism: false,

package/internal/stores/mesh/cells.js

@@ -1,175 +0,0 @@
-// Third party imports
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
-
-import { useDataStyleStateStore } from "../data_style_state"
-import { useViewerStore } from "@ogw_front/stores/viewer"
-
-// Local constants
-const mesh_cells_schemas = viewer_schemas.opengeodeweb_viewer.mesh.cells
-export function useMeshCellsStyle() {
-  const dataStyleStateStore = useDataStyleStateStore()
-  const viewerStore = useViewerStore()
-
-  function meshCellsStyle(id) {
-    return dataStyleStateStore.getStyle(id).cells
-  }
-
-  function meshCellsVisibility(id) {
-    return meshCellsStyle(id).visibility
-  }
-  function setMeshCellsVisibility(id, visibility) {
-    const cells_style = meshCellsStyle(id)
-    return viewerStore.request(
-      mesh_cells_schemas.visibility,
-      { id, visibility },
-      {
-        response_function: () => {
-          cells_style.visibility = visibility
-          console.log(
-            setMeshCellsVisibility.name,
-            { id },
-            meshCellsVisibility(id),
-          )
-        },
-      },
-    )
-  }
-
-  function meshCellsColor(id) {
-    return meshCellsStyle(id).coloring.color
-  }
-  function setMeshCellsColor(id, color) {
-    const coloring_style = meshCellsStyle(id).coloring
-    return viewerStore.request(
-      mesh_cells_schemas.color,
-      { id, color },
-      {
-        response_function: () => {
-          coloring_style.color = color
-          console.log(
-            setMeshCellsColor.name,
-            { id },
-            JSON.stringify(meshCellsColor(id)),
-          )
-        },
-      },
-    )
-  }
-
-  function meshCellsTextures(id) {
-    return meshCellsStyle(id).coloring.textures
-  }
-  function setMeshCellsTextures(id, textures) {
-    const coloring_style = meshCellsStyle(id).coloring
-    return viewerStore.request(
-      mesh_cells_schemas.apply_textures,
-      { id, textures },
-      {
-        response_function: () => {
-          coloring_style.textures = textures
-          console.log(setMeshCellsTextures.name, { id }, meshCellsTextures(id))
-        },
-      },
-    )
-  }
-
-  function meshCellsVertexAttribute(id) {
-    return meshCellsStyle(id).coloring.vertex
-  }
-
-  function setMeshCellsVertexAttribute(id, vertex_attribute) {
-    const coloring_style = meshCellsStyle(id).coloring
-    return viewerStore.request(
-      mesh_cells_schemas.vertex_attribute,
-      { id, ...vertex_attribute },
-      {
-        response_function: () => {
-          coloring_style.vertex = vertex_attribute
-          console.log(
-            setMeshCellsVertexAttribute.name,
-            { id },
-            meshCellsVertexAttribute(id),
-          )
-        },
-      },
-    )
-  }
-
-  function meshCellsCellAttribute(id) {
-    return meshCellsStyle(id).coloring.cell
-  }
-  function setMeshCellsCellAttribute(id, cell_attribute) {
-    const coloring_style = meshCellsStyle(id).coloring
-    return viewerStore.request(
-      mesh_cells_schemas.cell_attribute,
-      { id, ...cell_attribute },
-      {
-        response_function: () => {
-          coloring_style.cell = cell_attribute
-          console.log(
-            setMeshCellsCellAttribute.name,
-            { id },
-            meshCellsCellAttribute(id),
-          )
-        },
-      },
-    )
-  }
-
-  function meshCellsActiveColoring(id) {
-    return meshCellsStyle(id).coloring.active
-  }
-  function setMeshCellsActiveColoring(id, type) {
-    const coloring = meshCellsStyle(id).coloring
-    coloring.active = type
-    console.log(
-      setMeshCellsActiveColoring.name,
-      { id },
-      meshCellsActiveColoring(id),
-    )
-    if (type === "color") {
-      return setMeshCellsColor(id, coloring.color)
-    } else if (type === "textures") {
-      if (coloring.textures === null) {
-        throw new Error("Textures not set")
-      }
-      return setMeshCellsTextures(id, coloring.textures)
-    } else if (type === "vertex") {
-      if (coloring.vertex === null) {
-        throw new Error("Vertex attribute not set")
-      }
-      return setMeshCellsVertexAttribute(id, coloring.vertex)
-    } else if (type === "cell") {
-      if (coloring.cell === null) {
-        throw new Error("Cell attribute not set")
-      }
-      return setMeshCellsCellAttribute(id, coloring.cell)
-    } else {
-      throw new Error("Unknown mesh cells coloring type: " + type)
-    }
-  }
-
-  function applyMeshCellsStyle(id) {
-    const style = meshCellsStyle(id)
-    return Promise.all([
-      setMeshCellsVisibility(id, style.visibility),
-      setMeshCellsActiveColoring(id, style.coloring.active),
-    ])
-  }
-
-  return {
-    meshCellsVisibility,
-    meshCellsActiveColoring,
-    meshCellsColor,
-    meshCellsTextures,
-    meshCellsCellAttribute,
-    meshCellsVertexAttribute,
-    setMeshCellsVisibility,
-    setMeshCellsActiveColoring,
-    setMeshCellsColor,
-    setMeshCellsTextures,
-    setMeshCellsVertexAttribute,
-    setMeshCellsCellAttribute,
-    applyMeshCellsStyle,
-  }
-}

package/internal/stores/mesh/edges.js

@@ -1,171 +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_edges_schemas = viewer_schemas.opengeodeweb_viewer.mesh.edges
-
-export function useMeshEdgesStyle() {
-  const dataStyleStateStore = useDataStyleStateStore()
-  const viewerStore = useViewerStore()
-
-  function meshEdgesStyle(id) {
-    return dataStyleStateStore.getStyle(id).edges
-  }
-
-  function meshEdgesVisibility(id) {
-    return meshEdgesStyle(id).visibility
-  }
-  function setMeshEdgesVisibility(id, visibility) {
-    return viewerStore.request(
-      mesh_edges_schemas.visibility,
-      { id, visibility },
-      {
-        response_function: () => {
-          meshEdgesStyle(id).visibility = visibility
-          console.log(
-            setMeshEdgesVisibility.name,
-            { id },
-            meshEdgesVisibility(id),
-          )
-        },
-      },
-    )
-  }
-
-  function meshEdgesActiveColoring(id) {
-    return meshEdgesStyle(id).coloring.active
-  }
-  function setMeshEdgesActiveColoring(id, type) {
-    const coloring = meshEdgesStyle(id).coloring
-    coloring.active = type
-    console.log(
-      setMeshEdgesActiveColoring.name,
-      { id },
-      meshEdgesActiveColoring(id),
-    )
-    if (type === "color") {
-      return setMeshEdgesColor(id, coloring.color)
-    } else if (type === "vertex") {
-      if (coloring.vertex === null) {
-        throw new Error("Vertex attribute not set")
-      }
-      return setMeshEdgesVertexAttribute(id, coloring.vertex)
-    } else if (type === "edge") {
-      if (coloring.edge === null) {
-        throw new Error("Edge attribute not set")
-      }
-      return setMeshEdgesEdgeAttribute(id, coloring.edge)
-    } else {
-      throw new Error("Unknown mesh edges coloring type: " + type)
-    }
-  }
-
-  function meshEdgesColor(id) {
-    return meshEdgesStyle(id).coloring.color
-  }
-  function setMeshEdgesColor(id, color) {
-    const coloring_style = meshEdgesStyle(id).coloring
-    return viewerStore.request(
-      mesh_edges_schemas.color,
-      { id, color },
-      {
-        response_function: () => {
-          coloring_style.color = color
-          console.log(
-            setMeshEdgesColor.name,
-            { id },
-            JSON.stringify(meshEdgesColor(id)),
-          )
-        },
-      },
-    )
-  }
-
-  function meshEdgesWidth(id) {
-    return meshEdgesStyle(id).width
-  }
-  function setMeshEdgesWidth(id, width) {
-    const edges_style = meshEdgesStyle(id)
-    return viewerStore.request(
-      mesh_edges_schemas.width,
-      { id, width },
-      {
-        response_function: () => {
-          edges_style.width = width
-          console.log(setMeshEdgesWidth.name, { id }, meshEdgesWidth(id))
-        },
-      },
-    )
-  }
-
-  function meshEdgesVertexAttribute(id) {
-    return meshEdgesStyle(id).coloring.vertex
-  }
-  function setMeshEdgesVertexAttribute(id, vertex_attribute) {
-    const coloring_style = meshEdgesStyle(id).coloring
-    return viewerStore.request(
-      mesh_edges_schemas.vertex_attribute,
-      { id, ...vertex_attribute },
-      {
-        response_function: () => {
-          coloring_style.vertex = vertex_attribute
-          console.log(
-            setMeshEdgesVertexAttribute.name,
-            { id },
-            meshEdgesVertexAttribute(id),
-          )
-        },
-      },
-    )
-  }
-
-  function meshEdgesEdgeAttribute(id) {
-    return meshEdgesStyle(id).coloring.edge
-  }
-  function setMeshEdgesEdgeAttribute(id, edge_attribute) {
-    const coloring_style = meshEdgesStyle(id).coloring
-    return viewerStore.request(
-      mesh_edges_schemas.edge_attribute,
-      { id, ...edge_attribute },
-      {
-        response_function: () => {
-          coloring_style.edge = edge_attribute
-          console.log(
-            setMeshEdgesEdgeAttribute.name,
-            { id },
-            meshEdgesEdgeAttribute(id),
-          )
-        },
-      },
-    )
-  }
-
-  function applyMeshEdgesStyle(id) {
-    const style = meshEdgesStyle(id)
-    return Promise.all([
-      setMeshEdgesVisibility(id, style.visibility),
-      setMeshEdgesActiveColoring(id, style.coloring.active),
-      setMeshEdgesWidth(id, style.width),
-    ])
-  }
-
-  return {
-    applyMeshEdgesStyle,
-    meshEdgesActiveColoring,
-    meshEdgesColor,
-    meshEdgesVisibility,
-    meshEdgesWidth,
-    meshEdgesVertexAttribute,
-    meshEdgesEdgeAttribute,
-    setMeshEdgesActiveColoring,
-    setMeshEdgesColor,
-    setMeshEdgesVisibility,
-    setMeshEdgesWidth,
-    setMeshEdgesVertexAttribute,
-    setMeshEdgesEdgeAttribute,
-  }
-}

package/internal/stores/mesh/points.js

@@ -1,142 +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_points_schemas = viewer_schemas.opengeodeweb_viewer.mesh.points
-
-export function useMeshPointsStyle() {
-  const dataStyleStateStore = useDataStyleStateStore()
-  const viewerStore = useViewerStore()
-
-  function meshPointsStyle(id) {
-    return dataStyleStateStore.getStyle(id).points
-  }
-
-  function meshPointsVisibility(id) {
-    return meshPointsStyle(id).visibility
-  }
-  function setMeshPointsVisibility(id, visibility) {
-    const points_style = meshPointsStyle(id)
-    return viewerStore.request(
-      mesh_points_schemas.visibility,
-      { id, visibility },
-      {
-        response_function: () => {
-          points_style.visibility = visibility
-          console.log(
-            setMeshPointsVisibility.name,
-            { id },
-            meshPointsVisibility(id),
-          )
-        },
-      },
-    )
-  }
-
-  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 setMeshPointsColor(id, coloring.color)
-    } else if (type === "vertex") {
-      if (coloring.vertex === null) {
-        throw new Error("Vertex attribute not set")
-      }
-      return setMeshPointsVertexAttribute(id, coloring.vertex)
-    } else {
-      throw new Error("Unknown mesh points coloring type: " + type)
-    }
-  }
-
-  function meshPointsColor(id) {
-    return meshPointsStyle(id).coloring.color
-  }
-  function setMeshPointsColor(id, color) {
-    const coloring_style = meshPointsStyle(id).coloring
-    return viewerStore.request(
-      mesh_points_schemas.color,
-      { id, color },
-      {
-        response_function: () => {
-          coloring_style.color = color
-          console.log(
-            setMeshPointsColor.name,
-            { id },
-            JSON.stringify(meshPointsColor(id)),
-          )
-        },
-      },
-    )
-  }
-  function meshPointsVertexAttribute(id) {
-    return meshPointsStyle(id).coloring.vertex
-  }
-  function setMeshPointsVertexAttribute(id, vertex_attribute) {
-    const coloring_style = meshPointsStyle(id).coloring
-    return viewerStore.request(
-      mesh_points_schemas.vertex_attribute,
-      { id, ...vertex_attribute },
-      {
-        response_function: () => {
-          coloring_style.vertex = vertex_attribute
-          console.log(
-            setMeshPointsVertexAttribute.name,
-            { id },
-            meshPointsVertexAttribute(id),
-          )
-        },
-      },
-    )
-  }
-
-  function meshPointsSize(id) {
-    return meshPointsStyle(id).size
-  }
-  function setMeshPointsSize(id, size) {
-    return viewerStore.request(
-      mesh_points_schemas.size,
-      { id, size },
-      {
-        response_function: () => {
-          meshPointsStyle(id).size = size
-          console.log(setMeshPointsSize.name, { id }, meshPointsSize(id))
-        },
-      },
-    )
-  }
-
-  function applyMeshPointsStyle(id) {
-    const style = meshPointsStyle(id)
-    return Promise.all([
-      setMeshPointsVisibility(id, style.visibility),
-      setMeshPointsActiveColoring(id, style.coloring.active),
-      setMeshPointsSize(id, style.size),
-    ])
-  }
-
-  return {
-    meshPointsVisibility,
-    meshPointsActiveColoring,
-    meshPointsColor,
-    meshPointsVertexAttribute,
-    meshPointsSize,
-    setMeshPointsVisibility,
-    setMeshPointsActiveColoring,
-    setMeshPointsColor,
-    setMeshPointsVertexAttribute,
-    setMeshPointsSize,
-    applyMeshPointsStyle,
-  }
-}