@geode/opengeodeweb-front 10.3.1 → 10.3.2-rc.1

package/internal/stores/data_style/mesh/polygons/polygon.js

@@ -18,26 +18,15 @@ export function useMeshPolygonsPolygonAttributeStyle() {
     return meshPolygonsCommonStyle.meshPolygonsColoring(id).polygon
   }
 
-  async function updateMeshPolygonsPolygonAttribute(id) {
-    const name = meshPolygonsPolygonAttributeName(id)
-    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name)
-    await meshPolygonsPolygonAttributeRange(
-      id,
-      storedConfig.minimum,
-      storedConfig.maximum,
-    )
-    await meshPolygonsPolygonAttributeColorMap(id, storedConfig.colorMap)
-  }
-
   function meshPolygonsPolygonAttributeStoredConfig(id, name) {
     const { storedConfigs } = meshPolygonsPolygonAttribute(id)
     if (name in storedConfigs) {
       return storedConfigs[name]
     }
     return setMeshPolygonsPolygonAttributeStoredConfig(id, name, {
-      minimum: 0,
-      maximum: 1,
-      colorMap: "Cool to Warm",
+      minimum: undefined,
+      maximum: undefined,
+      colorMap: undefined,
     })
   }
 
@@ -46,7 +35,7 @@ export function useMeshPolygonsPolygonAttributeStyle() {
     name,
     { minimum, maximum, colorMap },
   ) {
-    const { storedConfigs } = meshPolygonsPolygonAttribute(id)
+    const storedConfigs = meshPolygonsPolygonAttribute(id).storedConfigs
     storedConfigs[name] = { minimum, maximum, colorMap }
     return storedConfigs[name]
   }
@@ -59,8 +48,13 @@ export function useMeshPolygonsPolygonAttributeStyle() {
       meshPolygonsPolygonAttributeSchemas.name,
       { id, name },
       {
-        response_function: () => {
+        response_function: async () => {
           meshPolygonsPolygonAttribute(id).name = name
+          const { minimum, maximum } = meshPolygonsPolygonAttributeStoredConfig(
+            id,
+            name,
+          )
+          await setMeshPolygonsPolygonAttributeRange(id, minimum, maximum)
           console.log(
             setMeshPolygonsPolygonAttributeName.name,
             { id },
@@ -81,29 +75,12 @@ export function useMeshPolygonsPolygonAttributeStyle() {
     )
     return [minimum, maximum]
   }
-  async function setMeshPolygonsPolygonAttributeRange(id, minimum, maximum) {
-    console.log(setMeshPolygonsPolygonAttributeRange.name, {
-      id,
-      minimum,
-      maximum,
-    })
+  function setMeshPolygonsPolygonAttributeRange(id, minimum, maximum) {
     const name = meshPolygonsPolygonAttributeName(id)
     const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name)
-    return viewerStore.request(
-      meshPolygonsPolygonAttributeSchemas.scalar_range,
-      { id, minimum, maximum },
-      {
-        response_function: () => {
-          storedConfig.minimum = minimum
-          storedConfig.maximum = maximum
-          console.log(
-            setMeshPolygonsPolygonAttributeRange.name,
-            { id },
-            meshPolygonsPolygonAttributeRange(id),
-          )
-        },
-      },
-    )
+    storedConfig.minimum = minimum
+    storedConfig.maximum = maximum
+    return setMeshPolygonsPolygonAttributeColorMap(id, storedConfig.colorMap)
   }
 
   function meshPolygonsPolygonAttributeColorMap(id) {
@@ -115,6 +92,14 @@ export function useMeshPolygonsPolygonAttributeStyle() {
   function setMeshPolygonsPolygonAttributeColorMap(id, colorMap) {
     const name = meshPolygonsPolygonAttributeName(id)
     const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name)
+    if (
+      storedConfig.minimum === undefined ||
+      storedConfig.maximum === undefined ||
+      colorMap === undefined
+    ) {
+      storedConfig.colorMap = colorMap
+      return
+    }
     const points = getRGBPointsFromPreset(colorMap)
     const { minimum, maximum } = storedConfig
     return viewerStore.request(
@@ -137,9 +122,9 @@ export function useMeshPolygonsPolygonAttributeStyle() {
     meshPolygonsPolygonAttributeName,
     meshPolygonsPolygonAttributeRange,
     meshPolygonsPolygonAttributeColorMap,
+    meshPolygonsPolygonAttributeStoredConfig,
     setMeshPolygonsPolygonAttributeName,
     setMeshPolygonsPolygonAttributeRange,
     setMeshPolygonsPolygonAttributeColorMap,
-    updateMeshPolygonsPolygonAttribute,
   }
 }

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

@@ -18,26 +18,15 @@ export function useMeshPolygonsVertexAttributeStyle() {
     return meshPolygonsCommonStyle.meshPolygonsColoring(id).vertex
   }
 
-  async function updateMeshPolygonsVertexAttribute(id) {
-    const name = meshPolygonsVertexAttributeName(id)
-    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name)
-    await meshPolygonsVertexAttributeRange(
-      id,
-      storedConfig.minimum,
-      storedConfig.maximum,
-    )
-    await meshPolygonsVertexAttributeColorMap(id, storedConfig.colorMap)
-  }
-
   function meshPolygonsVertexAttributeStoredConfig(id, name) {
     const { storedConfigs } = meshPolygonsVertexAttribute(id)
     if (name in storedConfigs) {
       return storedConfigs[name]
     }
     return setMeshPolygonsVertexAttributeStoredConfig(id, name, {
-      minimum: 0,
-      maximum: 1,
-      colorMap: "Cool to Warm",
+      minimum: undefined,
+      maximum: undefined,
+      colorMap: undefined,
     })
   }
 
@@ -46,7 +35,7 @@ export function useMeshPolygonsVertexAttributeStyle() {
     name,
     { minimum, maximum, colorMap },
   ) {
-    const { storedConfigs } = meshPolygonsVertexAttribute(id)
+    const storedConfigs = meshPolygonsVertexAttribute(id).storedConfigs
     storedConfigs[name] = { minimum, maximum, colorMap }
     return storedConfigs[name]
   }
@@ -67,10 +56,11 @@ export function useMeshPolygonsVertexAttributeStyle() {
       {
         response_function: async () => {
           meshPolygonsVertexAttribute(id).name = name
-          const { minimum, maximum, colorMap } =
-            meshPolygonsVertexAttributeStoredConfig(id, name)
+          const { minimum, maximum } = meshPolygonsVertexAttributeStoredConfig(
+            id,
+            name,
+          )
           await setMeshPolygonsVertexAttributeRange(id, minimum, maximum)
-          await setMeshPolygonsVertexAttributeColorMap(id, colorMap)
           console.log(
             setMeshPolygonsVertexAttributeName.name,
             { id },
@@ -90,21 +80,9 @@ export function useMeshPolygonsVertexAttributeStyle() {
   function setMeshPolygonsVertexAttributeRange(id, minimum, maximum) {
     const name = meshPolygonsVertexAttributeName(id)
     const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name)
-    return viewerStore.request(
-      meshPolygonsVertexAttributeSchemas.scalar_range,
-      { id, minimum, maximum },
-      {
-        response_function: () => {
-          storedConfig.minimum = minimum
-          storedConfig.maximum = maximum
-          console.log(
-            setMeshPolygonsVertexAttributeRange.name,
-            { id },
-            meshPolygonsVertexAttributeRange(id),
-          )
-        },
-      },
-    )
+    storedConfig.minimum = minimum
+    storedConfig.maximum = maximum
+    return setMeshPolygonsVertexAttributeColorMap(id, storedConfig.colorMap)
   }
 
   function meshPolygonsVertexAttributeColorMap(id) {
@@ -116,6 +94,14 @@ export function useMeshPolygonsVertexAttributeStyle() {
   function setMeshPolygonsVertexAttributeColorMap(id, colorMap) {
     const name = meshPolygonsVertexAttributeName(id)
     const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name)
+    if (
+      storedConfig.minimum === undefined ||
+      storedConfig.maximum === undefined ||
+      colorMap === undefined
+    ) {
+      storedConfig.colorMap = colorMap
+      return
+    }
     const points = getRGBPointsFromPreset(colorMap)
     const { minimum, maximum } = storedConfig
 
@@ -145,9 +131,9 @@ export function useMeshPolygonsVertexAttributeStyle() {
     meshPolygonsVertexAttributeName,
     meshPolygonsVertexAttributeRange,
     meshPolygonsVertexAttributeColorMap,
+    meshPolygonsVertexAttributeStoredConfig,
     setMeshPolygonsVertexAttributeName,
     setMeshPolygonsVertexAttributeRange,
     setMeshPolygonsVertexAttributeColorMap,
-    updateMeshPolygonsVertexAttribute,
   }
 }

package/internal/stores/data_style/mesh/polyhedra/polyhedron.js

@@ -18,26 +18,15 @@ export function useMeshPolyhedraPolyhedronAttributeStyle() {
     return meshPolyhedraCommonStyle.meshPolyhedraColoring(id).polyhedron
   }
 
-  async function updateMeshPolyhedraPolyhedronAttribute(id) {
-    const name = meshPolyhedraPolyhedronAttributeName(id)
-    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
-    await meshPolyhedraPolyhedronAttributeRange(
-      id,
-      storedConfig.minimum,
-      storedConfig.maximum,
-    )
-    await meshPolyhedraPolyhedronAttributeColorMap(id, storedConfig.colorMap)
-  }
-
   function meshPolyhedraPolyhedronAttributeStoredConfig(id, name) {
     const { storedConfigs } = meshPolyhedraPolyhedronAttribute(id)
     if (name in storedConfigs) {
       return storedConfigs[name]
     }
     return setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, {
-      minimum: 0,
-      maximum: 1,
-      colorMap: "Cool to Warm",
+      minimum: undefined,
+      maximum: undefined,
+      colorMap: undefined,
     })
   }
 
@@ -46,7 +35,7 @@ export function useMeshPolyhedraPolyhedronAttributeStyle() {
     name,
     { minimum, maximum, colorMap },
   ) {
-    const { storedConfigs } = meshPolyhedraPolyhedronAttribute(id)
+    const storedConfigs = meshPolyhedraPolyhedronAttribute(id).storedConfigs
     storedConfigs[name] = { minimum, maximum, colorMap }
     return storedConfigs[name]
   }
@@ -61,10 +50,9 @@ export function useMeshPolyhedraPolyhedronAttributeStyle() {
       {
         response_function: async () => {
           meshPolyhedraPolyhedronAttribute(id).name = name
-          const { minimum, maximum, colorMap } =
+          const { minimum, maximum } =
             meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
           await setMeshPolyhedraPolyhedronAttributeRange(id, minimum, maximum)
-          await setMeshPolyhedraPolyhedronAttributeColorMap(id, colorMap)
           console.log(
             setMeshPolyhedraPolyhedronAttributeName.name,
             { id },
@@ -83,20 +71,11 @@ export function useMeshPolyhedraPolyhedronAttributeStyle() {
   function setMeshPolyhedraPolyhedronAttributeRange(id, minimum, maximum) {
     const name = meshPolyhedraPolyhedronAttributeName(id)
     const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
-    return viewerStore.request(
-      meshPolyhedraPolyhedronAttributeSchemas.scalar_range,
-      { id, minimum, maximum },
-      {
-        response_function: () => {
-          storedConfig.minimum = minimum
-          storedConfig.maximum = maximum
-          console.log(
-            setMeshPolyhedraPolyhedronAttributeRange.name,
-            { id },
-            meshPolyhedraPolyhedronAttributeRange(id),
-          )
-        },
-      },
+    storedConfig.minimum = minimum
+    storedConfig.maximum = maximum
+    return setMeshPolyhedraPolyhedronAttributeColorMap(
+      id,
+      storedConfig.colorMap,
     )
   }
 
@@ -109,6 +88,14 @@ export function useMeshPolyhedraPolyhedronAttributeStyle() {
   function setMeshPolyhedraPolyhedronAttributeColorMap(id, colorMap) {
     const name = meshPolyhedraPolyhedronAttributeName(id)
     const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
+    if (
+      storedConfig.minimum === undefined ||
+      storedConfig.maximum === undefined ||
+      colorMap === undefined
+    ) {
+      storedConfig.colorMap = colorMap
+      return
+    }
     const points = getRGBPointsFromPreset(colorMap)
     const { minimum, maximum } = storedConfig
     return viewerStore.request(
@@ -131,9 +118,9 @@ export function useMeshPolyhedraPolyhedronAttributeStyle() {
     meshPolyhedraPolyhedronAttributeName,
     meshPolyhedraPolyhedronAttributeRange,
     meshPolyhedraPolyhedronAttributeColorMap,
+    meshPolyhedraPolyhedronAttributeStoredConfig,
     setMeshPolyhedraPolyhedronAttributeName,
     setMeshPolyhedraPolyhedronAttributeRange,
     setMeshPolyhedraPolyhedronAttributeColorMap,
-    updateMeshPolyhedraPolyhedronAttribute,
   }
 }

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

@@ -18,26 +18,15 @@ export function useMeshPolyhedraVertexAttributeStyle() {
     return meshPolyhedraCommonStyle.meshPolyhedraColoring(id).vertex
   }
 
-  async function updateMeshPolyhedraVertexAttribute(id) {
-    const name = meshPolyhedraVertexAttributeName(id)
-    const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name)
-    await meshPolyhedraVertexAttributeRange(
-      id,
-      storedConfig.minimum,
-      storedConfig.maximum,
-    )
-    await meshPolyhedraVertexAttributeColorMap(id, storedConfig.colorMap)
-  }
-
   function meshPolyhedraVertexAttributeStoredConfig(id, name) {
     const { storedConfigs } = meshPolyhedraVertexAttribute(id)
     if (name in storedConfigs) {
       return storedConfigs[name]
     }
     return setMeshPolyhedraVertexAttributeStoredConfig(id, name, {
-      minimum: 0,
-      maximum: 1,
-      colorMap: "Cool to Warm",
+      minimum: undefined,
+      maximum: undefined,
+      colorMap: undefined,
     })
   }
 
@@ -46,7 +35,7 @@ export function useMeshPolyhedraVertexAttributeStyle() {
     name,
     { minimum, maximum, colorMap },
   ) {
-    const { storedConfigs } = meshPolyhedraVertexAttribute(id)
+    const storedConfigs = meshPolyhedraVertexAttribute(id).storedConfigs
     storedConfigs[name] = { minimum, maximum, colorMap }
     return storedConfigs[name]
   }
@@ -67,10 +56,11 @@ export function useMeshPolyhedraVertexAttributeStyle() {
       {
         response_function: async () => {
           meshPolyhedraVertexAttribute(id).name = name
-          const { minimum, maximum, colorMap } =
-            meshPolyhedraVertexAttributeStoredConfig(id, name)
+          const { minimum, maximum } = meshPolyhedraVertexAttributeStoredConfig(
+            id,
+            name,
+          )
           await setMeshPolyhedraVertexAttributeRange(id, minimum, maximum)
-          await setMeshPolyhedraVertexAttributeColorMap(id, colorMap)
           console.log(
             setMeshPolyhedraVertexAttributeName.name,
             { id },
@@ -90,21 +80,9 @@ export function useMeshPolyhedraVertexAttributeStyle() {
   function setMeshPolyhedraVertexAttributeRange(id, minimum, maximum) {
     const name = meshPolyhedraVertexAttributeName(id)
     const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name)
-    return viewerStore.request(
-      meshPolyhedraVertexAttributeSchemas.scalar_range,
-      { id, minimum, maximum },
-      {
-        response_function: () => {
-          storedConfig.minimum = minimum
-          storedConfig.maximum = maximum
-          console.log(
-            setMeshPolyhedraVertexAttributeRange.name,
-            { id },
-            meshPolyhedraVertexAttributeRange(id),
-          )
-        },
-      },
-    )
+    storedConfig.minimum = minimum
+    storedConfig.maximum = maximum
+    return setMeshPolyhedraVertexAttributeColorMap(id, storedConfig.colorMap)
   }
 
   function meshPolyhedraVertexAttributeColorMap(id) {
@@ -116,6 +94,14 @@ export function useMeshPolyhedraVertexAttributeStyle() {
   function setMeshPolyhedraVertexAttributeColorMap(id, colorMap) {
     const name = meshPolyhedraVertexAttributeName(id)
     const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name)
+    if (
+      storedConfig.minimum === undefined ||
+      storedConfig.maximum === undefined ||
+      colorMap === undefined
+    ) {
+      storedConfig.colorMap = colorMap
+      return
+    }
     const points = getRGBPointsFromPreset(colorMap)
     const { minimum, maximum } = storedConfig
 
@@ -145,9 +131,9 @@ export function useMeshPolyhedraVertexAttributeStyle() {
     meshPolyhedraVertexAttributeName,
     meshPolyhedraVertexAttributeRange,
     meshPolyhedraVertexAttributeColorMap,
+    meshPolyhedraVertexAttributeStoredConfig,
     setMeshPolyhedraVertexAttributeName,
     setMeshPolyhedraVertexAttributeRange,
     setMeshPolyhedraVertexAttributeColorMap,
-    updateMeshPolyhedraVertexAttribute,
   }
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@geode/opengeodeweb-front",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "type": "module",
-  "version": "10.3.1",
+  "version": "10.3.2-rc.1",
   "main": "./nuxt.config.js",
   "scripts": {
     "lint": "eslint --fix --ext .js,.vue --ignore-path .gitignore .",
@@ -14,8 +14,8 @@
     "build": ""
   },
   "dependencies": {
-    "@geode/opengeodeweb-back": "latest",
-    "@geode/opengeodeweb-viewer": "latest",
+    "@geode/opengeodeweb-back": "next",
+    "@geode/opengeodeweb-viewer": "next",
     "@kitware/vtk.js": "33.3.0",
     "@mdi/font": "7.4.47",
     "@pinia/nuxt": "0.11.3",

package/tests/integration/microservices/viewer/requirements.txt

@@ -5,4 +5,4 @@
 #    pip-compile --output-file=tests/integration/microservices/viewer/requirements.txt tests/integration/microservices/viewer/requirements.in
 #
 
-opengeodeweb-viewer==1.*,>=1.15.2
+opengeodeweb-viewer==1.*,>=1.15.3rc1

package/app/components/Viewer/Options/CellAttributeSelector.vue

@@ -1,87 +0,0 @@
-<script setup>
-  import ViewerOptionsAttributeColorBar from "@ogw_front/components/Viewer/Options/AttributeColorBar"
-  import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
-  import { useGeodeStore } from "@ogw_front/stores/geode"
-
-  const geodeStore = useGeodeStore()
-
-  const cell_attribute_name = defineModel("cell_attribute_name", {
-    type: String,
-  })
-  const cell_attribute_range = defineModel("cell_attribute_range", {
-    type: Array,
-  })
-  const cell_attribute_color_map = defineModel("cell_attribute_color_map", {
-    type: String,
-  })
-  const cell_attributes = ref([])
-
-  const { id } = defineProps({
-    id: { type: String, required: true },
-  })
-
-  const model = defineModel()
-  const cell_attribute_names = ref([])
-  const cell_attribute = reactive({ name: cell_attribute_name.value })
-
-  onMounted(() => {
-    if (model.value !== undefined) {
-      cell_attribute_name.value = model.value.name
-    }
-  })
-
-  watch(cell_attribute_name, (value) => {
-    cell_attribute.name = value
-    model.value = cell_attribute
-  })
-
-  onMounted(() => {
-    getCellAttributes()
-  })
-
-  function getCellAttributes() {
-    geodeStore.request(
-      back_schemas.opengeodeweb_back.cell_attribute_names,
-      {
-        id,
-      },
-      {
-        response_function: (response) =>
-          (cell_attributes.value = response.attributes),
-      },
-    )
-  }
-
-  const currentAttribute = computed(() =>
-    cell_attributes.value.find(
-      (attr) => attr.attribute_name === cell_attribute_name.value,
-    ),
-  )
-
-  function resetRange() {
-    if (currentAttribute.value) {
-      cell_attribute_range.value = [
-        currentAttribute.value.min_value,
-        currentAttribute.value.max_value,
-      ]
-    }
-  }
-</script>
-
-<template>
-  <v-select
-    v-model="cell_attribute_name"
-    :items="cell_attributes.map((attribute) => attribute.attribute_name)"
-    item-title="attribute_name"
-    item-value="attribute_name"
-    label="Select an attribute"
-    density="compact"
-  />
-  <ViewerOptionsAttributeColorBar
-    v-if="cell_attribute_name"
-    v-model:minimum="rangeMin"
-    v-model:maximum="rangeMax"
-    v-model:colorMap="cell_attribute_color_map"
-    @reset="resetRange"
-  />
-</template>

package/app/components/Viewer/Options/EdgeAttributeSelector.vue

@@ -1,84 +0,0 @@
-<script setup>
-  import ViewerOptionsAttributeColorBar from "@ogw_front/components/Viewer/Options/AttributeColorBar"
-  import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
-  import { useGeodeStore } from "@ogw_front/stores/geode"
-
-  const geodeStore = useGeodeStore()
-
-  const edge_attribute_name = defineModel("edge_attribute_name", {
-    type: String,
-  })
-  const edge_attribute_range = defineModel("edge_attribute_range", {
-    type: Array,
-  })
-  const edge_attribute_color_map = defineModel("edge_attribute_color_map", {
-    type: String,
-  })
-  const edge_attributes = ref([])
-
-  const { id } = defineProps({
-    id: { type: String, required: true },
-  })
-
-  const rangeMin = computed({
-    get: () => edge_attribute_range.value[0],
-    set: (val) => {
-      edge_attribute_range.value = [val, edge_attribute_range.value[1]]
-    },
-  })
-  const rangeMax = computed({
-    get: () => edge_attribute_range.value[1],
-    set: (val) => {
-      edge_attribute_range.value = [edge_attribute_range.value[0], val]
-    },
-  })
-
-  onMounted(() => {
-    getEdgeAttributes()
-  })
-
-  function getEdgeAttributes() {
-    geodeStore.request(
-      back_schemas.opengeodeweb_back.edge_attribute_names,
-      { id: id },
-      {
-        response_function: (response) => {
-          edge_attributes.value = response.attributes
-        },
-      },
-    )
-  }
-
-  const currentAttribute = computed(() =>
-    edge_attributes.value.find(
-      (attr) => attr.attribute_name === edge_attribute_name.value,
-    ),
-  )
-
-  function resetRange() {
-    if (currentAttribute.value) {
-      edge_attribute_range.value = [
-        currentAttribute.value.min_value,
-        currentAttribute.value.max_value,
-      ]
-    }
-  }
-</script>
-
-<template>
-  <v-select
-    v-model="edge_attribute_name"
-    :items="edge_attributes.map((attribute) => attribute.attribute_name)"
-    item-title="attribute_name"
-    item-value="attribute_name"
-    label="Select an attribute"
-    density="compact"
-  />
-  <ViewerOptionsAttributeColorBar
-    v-if="edge_attribute_name"
-    v-model:minimum="rangeMin"
-    v-model:maximum="rangeMax"
-    v-model:colorMap="edge_attribute_color_map"
-    @reset="resetRange"
-  />
-</template>