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

package/internal_stores/mesh/polygons.js

@@ -2,105 +2,75 @@ import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schem
 const mesh_polygons_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polygons
 
 export function useMeshPolygonsStyle() {
-  /** State **/
   const dataStyleStore = useDataStyleStore()
 
-  /** Getters **/
-  function polygonsVisibility(id) {
-    return dataStyleStore.styles[id].polygons.visibility
-  }
-  function polygonsActiveColoring(id) {
-    return dataStyleStore.styles[id].polygons.coloring.active
-  }
-  function polygonsColor(id) {
-    return dataStyleStore.styles[id].polygons.coloring.color
-  }
-  function polygonsTextures(id) {
-    return dataStyleStore.styles[id].polygons.coloring.textures
-  }
-  function polygonsPolygonAttribute(id) {
-    return dataStyleStore.styles[id].polygons.coloring.polygon
-  }
-  function polygonsVertexAttribute(id) {
-    return dataStyleStore.styles[id].polygons.coloring.vertex
+  function meshPolygonsStyle(id) {
+    return dataStyleStore.getStyle(id).polygons
   }
 
-  /** Actions **/
-  function setPolygonsVisibility(id, visibility) {
+  function meshPolygonsVisibility(id) {
+    return meshPolygonsStyle(id).visibility
+  }
+  function setMeshPolygonsVisibility(id, visibility) {
+    const polygons_style = meshPolygonsStyle(id)
     return viewer_call(
-      {
-        schema: mesh_polygons_schemas.visibility,
-        params: { id, visibility },
-      },
+      { schema: mesh_polygons_schemas.visibility, params: { id, visibility } },
       {
         response_function: () => {
-          dataStyleStore.styles[id].polygons.visibility = visibility
+          polygons_style.visibility = visibility
           console.log(
-            "setPolygonsVisibility",
-            dataStyleStore.styles[id].polygons.visibility,
+            `${setMeshPolygonsVisibility.name} ${id} ${meshPolygonsVisibility(id)}`,
           )
         },
       },
     )
   }
-  function setPolygonsActiveColoring(id, type) {
-    console.log("setPolygonsActiveColoring", id, type)
-    if (type == "color") {
-      setPolygonsColor(id, dataStyleStore.styles[id].polygons.coloring.color)
-    } else if (type == "textures") {
-      const textures = dataStyleStore.styles[id].polygons.coloring.textures
-      if (textures !== null) setPolygonsTextures(id, textures)
-    } else if (type == "vertex") {
-      const vertex = dataStyleStore.styles[id].polygons.coloring.vertex
-      if (vertex !== null) {
-        console.log("vertex", vertex)
-        setPolygonsVertexAttribute(id, vertex)
-      }
-    } else if (type == "polygon") {
-      const polygon = dataStyleStore.styles[id].polygons.coloring.polygon
-      if (polygon !== null) setPolygonsPolygonAttribute(id, polygon)
-    } else throw new Error("Unknown polygons coloring type: " + type)
-    dataStyleStore.styles[id].polygons.coloring.active = type
-    console.log(
-      "setPolygonsActiveColoring",
-      dataStyleStore.styles[id].polygons.coloring.active,
-    )
+
+  function meshPolygonsColor(id) {
+    return meshPolygonsStyle(id).coloring.color
   }
-  function setPolygonsColor(id, color) {
+  function setMeshPolygonsColor(id, color) {
+    const coloring_style = meshPolygonsStyle(id).coloring
     return viewer_call(
-      {
-        schema: mesh_polygons_schemas.color,
-        params: { id, color },
-      },
+      { schema: mesh_polygons_schemas.color, params: { id, color } },
       {
         response_function: () => {
-          dataStyleStore.styles[id].polygons.coloring.color = color
+          coloring_style.color = color
           console.log(
-            "setPolygonsColor",
-            dataStyleStore.styles[id].polygons.coloring.color,
+            `${setMeshPolygonsColor.name} ${id} ${JSON.stringify(meshPolygonsColor(id))}`,
           )
         },
       },
     )
   }
-  function setPolygonsTextures(id, textures) {
+
+  function meshPolygonsTextures(id) {
+    return meshPolygonsStyle(id).coloring.textures
+  }
+  function setMeshPolygonsTextures(id, textures) {
+    const coloring_style = meshPolygonsStyle(id).coloring
     return viewer_call(
       {
-        schema: viewer_schemas.opengeodeweb_viewer.mesh.apply_textures,
+        schema: mesh_polygons_schemas.apply_textures,
         params: { id, textures },
       },
       {
         response_function: () => {
-          dataStyleStore.styles[id].polygons.coloring.textures = textures
+          coloring_style.textures = textures
           console.log(
-            "setPolygonsTextures",
-            dataStyleStore.styles[id].polygons.coloring.textures,
+            `${setMeshPolygonsTextures.name} ${id} ${meshPolygonsTextures(id)}`,
           )
         },
       },
     )
   }
-  function setPolygonsVertexAttribute(id, vertex_attribute) {
+
+  function meshPolygonsVertexAttribute(id) {
+    return meshPolygonsStyle(id).coloring.vertex
+  }
+
+  function setMeshPolygonsVertexAttribute(id, vertex_attribute) {
+    const coloring_style = meshPolygonsStyle(id).coloring
     return viewer_call(
       {
         schema: mesh_polygons_schemas.vertex_attribute,
@@ -108,16 +78,20 @@ export function useMeshPolygonsStyle() {
       },
       {
         response_function: () => {
-          dataStyleStore.styles[id].polygons.coloring.vertex = vertex_attribute
+          coloring_style.vertex = vertex_attribute
           console.log(
-            "setPolygonsVertexAttribute",
-            dataStyleStore.styles[id].polygons.coloring.vertex,
+            `${setMeshPolygonsVertexAttribute.name} ${id} ${meshPolygonsVertexAttribute(id)}`,
           )
         },
       },
     )
   }
-  function setPolygonsPolygonAttribute(id, polygon_attribute) {
+
+  function meshPolygonsPolygonAttribute(id) {
+    return meshPolygonsStyle(id).coloring.polygon
+  }
+  function setMeshPolygonsPolygonAttribute(id, polygon_attribute) {
+    const coloring_style = meshPolygonsStyle(id).coloring
     return viewer_call(
       {
         schema: mesh_polygons_schemas.polygon_attribute,
@@ -125,37 +99,55 @@ export function useMeshPolygonsStyle() {
       },
       {
         response_function: () => {
-          dataStyleStore.styles[id].polygons.coloring.polygon =
-            polygon_attribute
+          coloring_style.polygon = polygon_attribute
           console.log(
-            "setPolygonsPolygonAttribute",
-            dataStyleStore.styles[id].polygons.coloring.polygon,
+            `${setMeshPolygonsPolygonAttribute.name} ${id} ${meshPolygonsPolygonAttribute(id)}`,
           )
         },
       },
     )
   }
 
-  function applyPolygonsStyle(id, style) {
+  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" && coloring.textures !== null) {
+      return setMeshPolygonsTextures(id, coloring.textures)
+    } else if (type === "vertex" && coloring.vertex !== null) {
+      return setMeshPolygonsVertexAttribute(id, coloring.vertex)
+    } else if (type === "polygon" && coloring.polygon !== null) {
+      return setMeshPolygonsPolygonAttribute(id, coloring.polygon)
+    } else throw new Error("Unknown polygons coloring type: " + type)
+  }
+
+  function applyMeshPolygonsStyle(id, style) {
     return Promise.all([
-      setPolygonsVisibility(id, style.visibility),
-      setPolygonsActiveColoring(id, style.coloring.active),
+      setMeshPolygonsVisibility(id, style.visibility),
+      setMeshPolygonsActiveColoring(id, style.coloring.active),
     ])
   }
 
   return {
-    polygonsVisibility,
-    polygonsActiveColoring,
-    polygonsColor,
-    polygonsTextures,
-    polygonsPolygonAttribute,
-    polygonsVertexAttribute,
-    setPolygonsVisibility,
-    setPolygonsActiveColoring,
-    setPolygonsColor,
-    setPolygonsTextures,
-    setPolygonsVertexAttribute,
-    setPolygonsPolygonAttribute,
-    applyPolygonsStyle,
+    meshPolygonsVisibility,
+    meshPolygonsActiveColoring,
+    meshPolygonsColor,
+    meshPolygonsTextures,
+    meshPolygonsPolygonAttribute,
+    meshPolygonsVertexAttribute,
+    setMeshPolygonsVisibility,
+    setMeshPolygonsActiveColoring,
+    setMeshPolygonsColor,
+    setMeshPolygonsTextures,
+    setMeshPolygonsVertexAttribute,
+    setMeshPolygonsPolygonAttribute,
+    applyMeshPolygonsStyle,
   }
 }

package/internal_stores/mesh/polyhedra.js

@@ -1,138 +1,150 @@
+// Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 const mesh_polyhedra_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra
 
 export function useMeshPolyhedraStyle() {
-  /** State **/
   const dataStyleStore = useDataStyleStore()
 
-  /** Getters **/
-  function polyhedraVisibility(id) {
-    return dataStyleStore.styles[id].polyhedra.visibility
-  }
-  function polyhedraActiveColoring(id) {
-    return dataStyleStore.styles[id].polyhedra.coloring.active
-  }
-  function polyhedraColor(id) {
-    return dataStyleStore.styles[id].polyhedra.coloring.color
-  }
-  function polyhedraVertexAttribute(id) {
-    return dataStyleStore.styles[id].polyhedra.coloring.vertex
-  }
-  function polyhedraPolygonAttribute(id) {
-    return dataStyleStore.styles[id].polyhedra.coloring.polygon
-  }
-  function polyhedraPolyhedronAttribute(id) {
-    return dataStyleStore.styles[id].polyhedra.coloring.polyhedron
+  function meshPolyhedraStyle(id) {
+    return dataStyleStore.getStyle(id).polyhedra
   }
 
-  /** Actions **/
-  function setPolyhedraVisibility(id, visibility) {
+  function meshPolyhedraVisibility(id) {
+    return meshPolyhedraStyle(id).visibility
+  }
+  function setMeshPolyhedraVisibility(id, visibility) {
+    const polyhedra_style = meshPolyhedraStyle(id)
     return viewer_call(
-      {
-        schema: mesh_polyhedra_schemas.visibility,
-        params: { id, visibility },
-      },
+      { schema: mesh_polyhedra_schemas.visibility, params: { id, visibility } },
       {
         response_function: () => {
-          dataStyleStore.styles[id].polyhedra.visibility = visibility
+          polyhedra_style.visibility = visibility
           console.log(
-            "setPolyhedraVisibility",
-            dataStyleStore.styles[id].polyhedra.visibility,
+            `${setMeshPolyhedraVisibility.name} ${id} ${meshPolyhedraVisibility(id)}`,
           )
         },
       },
     )
   }
-  function setPolyhedraActiveColoring(id, type) {
-    if (type == "color")
-      setPolyhedraColor(id, dataStyleStore.styles[id].polyhedra.coloring.color)
-    else if (type == "vertex") {
-      const vertex = dataStyleStore.styles[id].polyhedra.coloring.vertex
-      if (vertex !== null) setPolyhedraVertexAttribute(id, vertex)
-    } else if (type == "polyhedron") {
-      const polyhedron = dataStyleStore.styles[id].polyhedra.coloring.polyhedron
-      if (polyhedron !== null) setPolyhedraPolyhedronAttribute(id, polyhedron)
-    } else throw new Error("Unknown polyhedra coloring type: " + type)
-    dataStyleStore.styles[id].polyhedra.coloring.active = type
-    console.log(
-      "setPolyhedraActiveColoring",
-      dataStyleStore.styles[id].polyhedra.coloring.active,
-    )
+  function meshPolyhedraActiveColoring(id) {
+    return meshPolyhedraStyle(id).coloring.active
   }
-  function setPolyhedraColor(id, color) {
-    return viewer_call(
-      {
-        schema: mesh_polyhedra_schemas.color,
-        params: { id, color },
-      },
-      {
-        response_function: () => {
-          dataStyleStore.styles[id].polyhedra.coloring.color = color
-          console.log(
-            "setPolyhedraColor",
-            dataStyleStore.styles[id].polyhedra.coloring.color,
-          )
-        },
-      },
+  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" && coloring.vertex !== null) {
+      //   return setPolyhedraVertexAttribute(id, coloring.vertex)
+      // } else if (type === "polyhedron" && coloring.polyhedron !== null) {
+      //   return setPolyhedraPolyhedronAttribute(id, coloring.polyhedron)
+    } else throw new Error("Unknown mesh polyhedra coloring type: " + type)
   }
 
-  function setPolyhedraVertexAttribute(id, vertex_attribute) {
-    return viewer_call(
-      {
-        schema: mesh_polyhedra_schemas.vertex_attribute,
-        params: { id, ...vertex_attribute },
-      },
-      {
-        response_function: () => {
-          dataStyleStore.styles[id].polyhedra.coloring.vertex = vertex_attribute
-          console.log(
-            "setPolyhedraVertexAttribute",
-            dataStyleStore.styles[id].polyhedra.coloring.vertex,
-          )
-        },
-      },
-    )
+  function meshPolyhedraColor(id) {
+    return meshPolyhedraStyle(id).coloring.color
   }
-
-  function setPolyhedraPolyhedronAttribute(id, polyhedron_attribute) {
+  function setMeshPolyhedraColor(id, color) {
+    const coloring = meshPolyhedraStyle(id).coloring
     return viewer_call(
-      {
-        schema: mesh_polyhedra_schemas.polyhedron_attribute,
-        params: { id, ...polyhedron_attribute },
-      },
+      { schema: mesh_polyhedra_schemas.color, params: { id, color } },
       {
         response_function: () => {
-          dataStyleStore.styles[id].polyhedra.coloring.polyhedron =
-            polyhedron_attribute
+          coloring.color = color
           console.log(
-            "setPolyhedraPolyhedronAttribute",
-            dataStyleStore.styles[id].polyhedra.coloring.polyhedron,
+            `${setMeshPolyhedraColor.name} ${id} ${JSON.stringify(meshPolyhedraColor(id))}`,
           )
         },
       },
     )
   }
 
-  function applyPolyhedraStyle(id, style) {
+  // function polyhedraVertexAttribute(id) {
+  //   return meshPolyhedraStyle(id).coloring.vertex
+  // }
+  // function setPolyhedraVertexAttribute(id, vertex_attribute) {
+  //   const coloring_style = meshPolyhedraStyle(id).coloring
+  //   return viewer_call(
+  //     {
+  //       schema: mesh_polyhedra_schemas.vertex_attribute,
+  //       params: { id, ...vertex_attribute },
+  //     },
+  //     {
+  //       response_function: () => {
+  //         coloring_style.vertex = vertex_attribute
+  //         console.log(
+  //           `${setPolyhedraVertexAttribute.name} ${polyhedraVertexAttribute(id)}`,
+  //         )
+  //       },
+  //     },
+  //   )
+  // }
+
+  // function polyhedraPolygonAttribute(id) {
+  //   return meshPolyhedraStyle(id).coloring.polygon
+  // }
+  // function setPolyhedraPolygonAttribute(id, polygon_attribute) {
+  //   const coloring_style = meshPolyhedraStyle(id).coloring
+  //   return viewer_call(
+  //     {
+  //       schema: mesh_polyhedra_schemas.polygon_attribute,
+  //       params: { id, ...polygon_attribute },
+  //     },
+  //     {
+  //       response_function: () => {
+  //         coloring_style.polygon = polygon_attribute
+  //         console.log(
+  //           `${setPolyhedraPolygonAttribute.name} ${polyhedraPolygonAttribute(id)}`,
+  //         )
+  //       },
+  //     },
+  //   )
+  // }
+
+  // function polyhedraPolyhedronAttribute(id) {
+  //   return meshPolyhedraStyle(id).coloring.polyhedron
+  // }
+  // function setPolyhedraPolyhedronAttribute(id, polyhedron_attribute) {
+  //   const coloring = meshPolyhedraStyle(id).coloring
+  //   return viewer_call(
+  //     {
+  //       schema: mesh_polyhedra_schemas.polyhedron_attribute,
+  //       params: { id, ...polyhedron_attribute },
+  //     },
+  //     {
+  //       response_function: () => {
+  //         coloring.polyhedron = polyhedron_attribute
+  //         console.log(
+  //           `${setPolyhedraPolyhedronAttribute.name} ${polyhedraPolyhedronAttribute(id)}`,
+  //         )
+  //       },
+  //     },
+  //   )
+  // }
+
+  function applyMeshPolyhedraStyle(id, style) {
     return Promise.all([
-      setPolyhedraVisibility(id, style.visibility),
-      setPolyhedraActiveColoring(id, style.coloring.active),
+      setMeshPolyhedraVisibility(id, style.visibility),
+      setMeshPolyhedraActiveColoring(id, style.coloring.active),
     ])
   }
 
   return {
-    polyhedraVisibility,
-    polyhedraActiveColoring,
-    polyhedraColor,
-    polyhedraVertexAttribute,
-    polyhedraPolygonAttribute,
-    polyhedraPolyhedronAttribute,
-    setPolyhedraVisibility,
-    setPolyhedraActiveColoring,
-    setPolyhedraColor,
-    setPolyhedraVertexAttribute,
-    setPolyhedraPolyhedronAttribute,
-    applyPolyhedraStyle,
+    applyMeshPolyhedraStyle,
+    meshPolyhedraActiveColoring,
+    meshPolyhedraColor,
+    // polyhedraVertexAttribute,
+    meshPolyhedraVisibility,
+    // polyhedraPolyhedronAttribute,
+    // polyhedraPolygonAttribute,
+    setMeshPolyhedraActiveColoring,
+    setMeshPolyhedraColor,
+    // setPolyhedraPolyhedronAttribute,
+    // setPolyhedraPolygonAttribute,
+    // setPolyhedraVertexAttribute,
+    setMeshPolyhedraVisibility,
   }
 }

package/internal_stores/model/blocks.js

@@ -56,5 +56,3 @@ export function useBlocksStyle() {
     applyBlocksStyle,
   }
 }
-
-export default useBlocksStyle

package/internal_stores/model/corners.js

@@ -59,5 +59,3 @@ export function useCornersStyle() {
     applyCornersStyle,
   }
 }
-
-export default useCornersStyle

package/internal_stores/model/lines.js

@@ -77,5 +77,3 @@ export function useLinesStyle() {
     applyLinesStyle,
   }
 }
-
-export default useLinesStyle

package/internal_stores/model/surfaces.js

@@ -56,5 +56,3 @@ export function useSurfacesStyle() {
     applySurfacesStyle,
   }
 }
-
-export default useSurfacesStyle

package/package.json

@@ -38,9 +38,9 @@
   "overrides": {
     "vue": "latest"
   },
-  "description": "OpenSource Vue/Vuetify framework for web applications",
+  "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "type": "module",
-  "version": "9.12.0",
+  "version": "9.12.1-rc.1",
   "main": "./nuxt.config.js",
   "dependencies": {
     "@geode/opengeodeweb-back": "latest",

package/stores/data_base.js

@@ -5,10 +5,8 @@ export const useDataBaseStore = defineStore("dataBase", () => {
   const treeview_store = useTreeviewStore()
   const hybridViewerStore = useHybridViewerStore()
 
-  /** State **/
   const db = reactive({})
 
-  /** Getters **/
   function itemMetaDatas(id) {
     return db[id]
   }
@@ -41,13 +39,13 @@ export const useDataBaseStore = defineStore("dataBase", () => {
     return null
   }
 
-  /** Actions **/
   async function registerObject(id) {
     return viewer_call({
       schema: viewer_schemas.opengeodeweb_viewer.generic.register,
       params: { id },
     })
   }
+
   async function addItem(
     id,
     value = {

package/stores/data_style.js

@@ -12,14 +12,16 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
   /** Actions **/
   function addDataStyle(id, geode_object, object_type) {
     dataStyleState.styles[id] = getDefaultStyle(geode_object)
+    const promise_array = []
     if (object_type === "mesh") {
-      return meshStyleStore.applyMeshDefaultStyle(id)
+      promise_array.push(meshStyleStore.applyMeshDefaultStyle(id))
     } else if (object_type === "model") {
-      return [
-        modelStyleStore.setMeshComponentsDefaultStyle(id),
-        modelStyleStore.applyModelDefaultStyle(id),
-      ]
+      promise_array.push(modelStyleStore.setMeshComponentsDefaultStyle(id))
+      promise_array.push(modelStyleStore.applyModelDefaultStyle(id))
+    } else {
+      throw new Error("Unknown object type")
     }
+    return Promise.all(promise_array)
   }
 
   function setVisibility(id, visibility) {

package/stores/infra.js

@@ -50,13 +50,11 @@ export const useInfraStore = defineStore("infra", {
         if (this.app_mode == appMode.appMode.DESKTOP) {
           const viewer_store = useViewerStore()
           const geode_store = useGeodeStore()
-          const back_port = await window.electronAPI.run_back(
-            geode_store.default_local_port,
-          )
+          const [back_port, viewer_port] = await Promise.all([
+            window.electronAPI.run_back(),
+            window.electronAPI.run_viewer(),
+          ])
           geode_store.$patch({ default_local_port: back_port })
-          const viewer_port = await window.electronAPI.run_viewer(
-            viewer_store.default_local_port,
-          )
           viewer_store.$patch({ default_local_port: viewer_port })
         } else if (this.app_mode == appMode.appMode.CLOUD) {
           const { data, error } = await useFetch(this.lambda_url, {

package/stores/treeview.js

@@ -15,9 +15,16 @@ export const useTreeviewStore = defineStore("treeview", () => {
   function addItem(geodeObject, displayed_name, id, object_type) {
     dataStyleStore.addDataStyle(id, geodeObject, object_type)
     const child = { title: displayed_name, id, object_type }
+
     for (let i = 0; i < items.value.length; i++) {
       if (items.value[i].title === geodeObject) {
         items.value[i].children.push(child)
+        items.value[i].children.sort((a, b) =>
+          a.title.localeCompare(b.title, undefined, {
+            numeric: true,
+            sensitivity: "base",
+          }),
+        )
         selection.value.push(child)
         return
       }

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

@@ -5,4 +5,4 @@
 #    pip-compile --output-file=tests/integration/microservices/back/requirements.txt tests/integration/microservices/back/requirements.in
 #
 
-opengeodeweb-back==5.*,>=5.11.0
+opengeodeweb-back==5.*,>=5.11.1rc1

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.11.5
+opengeodeweb-viewer==1.*,>=1.11.6rc2