@geode/opengeodeweb-front 9.11.2 → 9.11.3-rc.3

package/internal_stores/mesh/edges.js

@@ -2,105 +2,102 @@ import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schem
 const mesh_edges_schemas = viewer_schemas.opengeodeweb_viewer.mesh.edges
 
 export function useMeshEdgesStyle() {
-  /** State **/
   const dataStyleStore = useDataStyleStore()
 
-  /** Getters **/
   function edgesVisibility(id) {
     return dataStyleStore.styles[id].edges.visibility
   }
-  function edgesActiveColoring(id) {
-    return dataStyleStore.styles[id].edges.coloring.active
-  }
-  function edgesColor(id) {
-    return dataStyleStore.styles[id].edges.coloring.color
-  }
-  function edgesSize(id) {
-    return dataStyleStore.styles[id].edges.size
-  }
-
-  /** Actions **/
   function setEdgesVisibility(id, visibility) {
-    viewer_call(
+    const edges_style = dataStyleStore.styles[id].edges
+    return viewer_call(
       {
         schema: mesh_edges_schemas.visibility,
         params: { id, visibility },
       },
       {
         response_function: () => {
-          dataStyleStore.styles[id].edges.visibility = visibility
-          console.log(
-            "setEdgesVisibility",
-            dataStyleStore.styles[id].edges.visibility,
-          )
+          edges_style.visibility = visibility
+          console.log(`${setEdgesVisibility.name} ${edges_style.visibility}`)
         },
       },
     )
   }
-  function setEdgesActiveColoring(id, type) {
-    if (type == "color")
-      setEdgesColor(id, dataStyleStore.styles[id].edges.coloring.color)
-    else if (type == "vertex") {
-      const vertex = dataStyleStore.styles[id].edges.coloring.vertex
-      if (vertex !== null) setEdgesVertexAttribute(id, vertex)
-    } else if (type == "edges") {
-      const edges = dataStyleStore.styles[id].edges.coloring.edges
-      if (edges !== null) setEdgesEdgeAttribute(id, edges)
+
+  function edgesActiveColoring(id) {
+    return dataStyleStore.styles[id].edges.coloring.active
+  }
+  async function setEdgesActiveColoring(id, type) {
+    const coloring = dataStyleStore.styles[id].edges.coloring
+    if (type == "color") {
+      setEdgesColor(id, coloring.color)
+      // else if (type == "vertex") {
+      //   const vertex = coloring.vertex
+      // if (vertex !== null) setEdgesVertexAttribute(id, vertex)
+      // } else if (type == "edges") {
+      //   const edges = coloring.edges
+      //   if (edges !== null) setEdgesEdgeAttribute(id, edges)
     } else throw new Error("Unknown edges coloring type: " + type)
-    dataStyleStore.styles[id].edges.coloring.active = type
-    console.log(
-      "setEdgesActiveColoring",
-      dataStyleStore.styles[id].edges.coloring.active,
-    )
+    coloring.active = type
+    console.log(`${setEdgesActiveColoring.name} ${coloring.active}`)
   }
 
+  function edgesColor(id) {
+    return dataStyleStore.styles[id].edges.coloring.color
+  }
   function setEdgesColor(id, color) {
-    viewer_call(
+    const coloring_style = dataStyleStore.styles[id].edges.coloring
+    return viewer_call(
       {
         schema: mesh_edges_schemas.color,
         params: { id, color },
       },
       {
         response_function: () => {
-          dataStyleStore.styles[id].edges.coloring.color = color
+          coloring_style.color = color
           console.log(
-            "setEdgesColor",
-            dataStyleStore.styles[id].edges.coloring.color,
+            `${setEdgesColor.name} ${JSON.stringify(coloring_style.color)}`,
           )
         },
       },
     )
   }
-  function setEdgesSize(id, size) {
-    viewer_call(
+
+  function edgesWidth(id) {
+    return dataStyleStore.styles[id].edges.size
+  }
+  function setEdgesWidth(id, width) {
+    const edges_style = dataStyleStore.styles[id].edges
+    return viewer_call(
       {
-        schema: mesh_edges_schemas.size,
-        params: { id, size },
+        schema: mesh_edges_schemas.width,
+        params: { id, width },
       },
       {
         response_function: () => {
-          dataStyleStore.styles[id].edges.size = size
-          console.log("setEdgesSize", dataStyleStore.styles[id].edges.size)
+          edges_style.width = width
+          console.log(`${setEdgesWidth.name} ${edges_style.width}`)
         },
       },
     )
   }
 
-  function applyEdgesStyle(id, style) {
-    setEdgesVisibility(id, style.visibility)
-    setEdgesActiveColoring(id, style.coloring.active)
-    // setEdgesSize(id, style.size);
+  async function applyEdgesStyle(id, style) {
+    return Promise.all([
+      setEdgesVisibility(id, style.visibility),
+      setEdgesActiveColoring(id, style.coloring.active),
+      // setEdgesWidth(id, style.width);
+    ])
   }
 
   return {
-    edgesVisibility,
+    applyEdgesStyle,
     edgesActiveColoring,
     edgesColor,
-    edgesSize,
-    setEdgesVisibility,
+    edgesVisibility,
+    edgesWidth,
     setEdgesActiveColoring,
     setEdgesColor,
-    setEdgesSize,
-    applyEdgesStyle,
+    setEdgesVisibility,
+    setEdgesWidth,
   }
 }

package/internal_stores/mesh/index.js

@@ -13,32 +13,38 @@ export default function useMeshStyle() {
   const hybridViewerStore = useHybridViewerStore()
 
   function setMeshVisibility(id, visibility) {
-    viewer_call(
+    return viewer_call(
       {
         schema: viewer_schemas.opengeodeweb_viewer.mesh.visibility,
         params: { id, visibility },
       },
       {
         response_function: () => {
-          dataStyleStore.styles[id].visibility = visibility
           hybridViewerStore.setVisibility(id, visibility)
-          console.log("setMeshVisibility", dataStyleStore.styles[id].visibility)
+          dataStyleStore.styles[id].visibility = visibility
         },
       },
     )
   }
 
-  function applyMeshDefaultStyle(id) {
-    const id_style = dataStyleStore.styles[id]
-    for (const [key, value] of Object.entries(id_style)) {
-      if (key == "visibility") setMeshVisibility(id, value)
-      else if (key == "points") pointsStyleStore.applyPointsStyle(id, value)
-      else if (key == "edges") edgesStyleStore.applyEdgesStyle(id, value)
-      else if (key == "polygons")
-        polygonsStyleStore.applyPolygonsStyle(id, value)
-      else if (key == "polyhedra")
-        polyhedraStyleStore.applyPolyhedraStyle(id, value)
-    }
+  async function applyMeshDefaultStyle(id) {
+    return new Promise(async (resolve) => {
+      const id_style = dataStyleStore.styles[id]
+      for (const [key, value] of Object.entries(id_style)) {
+        if (key == "visibility") {
+          await setMeshVisibility(id, value)
+        } else if (key == "points") {
+          await pointsStyleStore.applyPointsStyle(id, value)
+        } else if (key == "edges") {
+          await edgesStyleStore.applyEdgesStyle(id, value)
+        } else if (key == "polygons") {
+          await polygonsStyleStore.applyPolygonsStyle(id, value)
+        } else if (key == "polyhedra") {
+          await polyhedraStyleStore.applyPolyhedraStyle(id, value)
+        }
+      }
+      resolve()
+    })
   }
 
   return {

package/internal_stores/mesh/points.js

@@ -24,7 +24,7 @@ export function useMeshPointsStyle() {
 
   /** Actions **/
   function setPointsVisibility(id, visibility) {
-    viewer_call(
+    return viewer_call(
       {
         schema: mesh_points_schemas.visibility,
         params: { id, visibility },
@@ -42,7 +42,7 @@ export function useMeshPointsStyle() {
   }
 
   function setPointsColor(id, color) {
-    viewer_call(
+    return viewer_call(
       {
         schema: viewer_schemas.opengeodeweb_viewer.mesh.points.color,
         params: { id, color },
@@ -59,7 +59,7 @@ export function useMeshPointsStyle() {
     )
   }
   function setPointsVertexAttribute(id, vertex_attribute) {
-    viewer_call(
+    return viewer_call(
       {
         schema: viewer_schemas.opengeodeweb_viewer.mesh.points.vertex_attribute,
         params: { id, ...vertex_attribute },
@@ -76,7 +76,7 @@ export function useMeshPointsStyle() {
     )
   }
   function setPointsSize(id, size) {
-    viewer_call(
+    return viewer_call(
       {
         schema: viewer_schemas.opengeodeweb_viewer.mesh.points.size,
         params: { id, size },
@@ -108,9 +108,11 @@ export function useMeshPointsStyle() {
   }
 
   function applyPointsStyle(id, style) {
-    setPointsVisibility(id, style.visibility)
-    setPointsActiveColoring(id, style.coloring.active)
-    setPointsSize(id, style.size)
+    return Promise.all([
+      setPointsVisibility(id, style.visibility),
+      setPointsActiveColoring(id, style.coloring.active),
+      setPointsSize(id, style.size),
+    ])
   }
 
   return {

package/internal_stores/mesh/polygons.js

@@ -27,7 +27,7 @@ export function useMeshPolygonsStyle() {
 
   /** Actions **/
   function setPolygonsVisibility(id, visibility) {
-    viewer_call(
+    return viewer_call(
       {
         schema: mesh_polygons_schemas.visibility,
         params: { id, visibility },
@@ -67,7 +67,7 @@ export function useMeshPolygonsStyle() {
     )
   }
   function setPolygonsColor(id, color) {
-    viewer_call(
+    return viewer_call(
       {
         schema: mesh_polygons_schemas.color,
         params: { id, color },
@@ -84,7 +84,7 @@ export function useMeshPolygonsStyle() {
     )
   }
   function setPolygonsTextures(id, textures) {
-    viewer_call(
+    return viewer_call(
       {
         schema: viewer_schemas.opengeodeweb_viewer.mesh.apply_textures,
         params: { id, textures },
@@ -101,7 +101,7 @@ export function useMeshPolygonsStyle() {
     )
   }
   function setPolygonsVertexAttribute(id, vertex_attribute) {
-    viewer_call(
+    return viewer_call(
       {
         schema: mesh_polygons_schemas.vertex_attribute,
         params: { id, ...vertex_attribute },
@@ -118,7 +118,7 @@ export function useMeshPolygonsStyle() {
     )
   }
   function setPolygonsPolygonAttribute(id, polygon_attribute) {
-    viewer_call(
+    return viewer_call(
       {
         schema: mesh_polygons_schemas.polygon_attribute,
         params: { id, ...polygon_attribute },
@@ -137,8 +137,10 @@ export function useMeshPolygonsStyle() {
   }
 
   function applyPolygonsStyle(id, style) {
-    setPolygonsVisibility(id, style.visibility)
-    setPolygonsActiveColoring(id, style.coloring.active)
+    return Promise.all([
+      setPolygonsVisibility(id, style.visibility),
+      setPolygonsActiveColoring(id, style.coloring.active),
+    ])
   }
 
   return {

package/internal_stores/mesh/polyhedra.js

@@ -27,7 +27,7 @@ export function useMeshPolyhedraStyle() {
 
   /** Actions **/
   function setPolyhedraVisibility(id, visibility) {
-    viewer_call(
+    return viewer_call(
       {
         schema: mesh_polyhedra_schemas.visibility,
         params: { id, visibility },
@@ -60,7 +60,7 @@ export function useMeshPolyhedraStyle() {
     )
   }
   function setPolyhedraColor(id, color) {
-    viewer_call(
+    return viewer_call(
       {
         schema: mesh_polyhedra_schemas.color,
         params: { id, color },
@@ -78,7 +78,7 @@ export function useMeshPolyhedraStyle() {
   }
 
   function setPolyhedraVertexAttribute(id, vertex_attribute) {
-    viewer_call(
+    return viewer_call(
       {
         schema: mesh_polyhedra_schemas.vertex_attribute,
         params: { id, ...vertex_attribute },
@@ -96,7 +96,7 @@ export function useMeshPolyhedraStyle() {
   }
 
   function setPolyhedraPolyhedronAttribute(id, polyhedron_attribute) {
-    viewer_call(
+    return viewer_call(
       {
         schema: mesh_polyhedra_schemas.polyhedron_attribute,
         params: { id, ...polyhedron_attribute },
@@ -115,8 +115,10 @@ export function useMeshPolyhedraStyle() {
   }
 
   function applyPolyhedraStyle(id, style) {
-    setPolyhedraVisibility(id, style.visibility)
-    setPolyhedraActiveColoring(id, style.coloring.active)
+    return Promise.all([
+      setPolyhedraVisibility(id, style.visibility),
+      setPolyhedraActiveColoring(id, style.coloring.active),
+    ])
   }
 
   return {

package/internal_stores/model/blocks.js

@@ -15,7 +15,7 @@ export function useBlocksStyle() {
   /** Actions **/
   function setBlockVisibility(id, block_ids, visibility) {
     const block_flat_indexes = dataBaseStore.getFlatIndexes(id, block_ids)
-    viewer_call(
+    return viewer_call(
       {
         schema: blocks_schemas.visibility,
         params: { id, block_ids: block_flat_indexes, visibility },

package/internal_stores/model/corners.js

@@ -14,7 +14,7 @@ export function useCornersStyle() {
   /** Actions **/
   function setCornerVisibility(id, corner_ids, visibility) {
     const corner_flat_indexes = dataBaseStore.getFlatIndexes(id, corner_ids)
-    viewer_call(
+    return viewer_call(
       {
         schema: corners_schemas.visibility,
         params: { id, block_ids: corner_flat_indexes, visibility },

package/internal_stores/model/edges.js

@@ -9,14 +9,7 @@ export function useModelEdgesStyle() {
   }
 
   function setModelEdgesVisibility(id, visibility) {
-    if (!dataStyleStore.styles[id]) {
-      dataStyleStore.styles[id] = {}
-    }
-    if (!dataStyleStore.styles[id].edges) {
-      dataStyleStore.styles[id].edges = {}
-    }
-
-    viewer_call(
+    return viewer_call(
       {
         schema: model_edges_schemas.visibility,
         params: { id, visibility },

package/internal_stores/model/index.js

@@ -63,7 +63,7 @@ export default function useModelStyle() {
   }
 
   function setModelVisibility(id, visibility) {
-    viewer_call(
+    return viewer_call(
       {
         schema: viewer_schemas.opengeodeweb_viewer.model.visibility,
         params: { id, visibility },

package/internal_stores/model/lines.js

@@ -18,7 +18,7 @@ export function useLinesStyle() {
   /** Actions **/
   function setLineVisibility(id, line_ids, visibility) {
     const line_flat_indexes = dataBaseStore.getFlatIndexes(id, line_ids)
-    viewer_call(
+    return viewer_call(
       {
         schema: lines_schemas.visibility,
         params: { id, block_ids: line_flat_indexes, visibility },
@@ -38,7 +38,7 @@ export function useLinesStyle() {
 
   function setLineColor(id, line_ids, color) {
     const line_flat_indexes = dataBaseStore.getFlatIndexes(id, line_ids)
-    viewer_call(
+    return viewer_call(
       {
         schema: lines_schemas.color,
         params: { id, block_ids: line_flat_indexes, color },

package/internal_stores/model/points.js

@@ -12,7 +12,7 @@ export function useModelPointsStyle() {
   }
 
   function setModelPointsVisibility(id, visibility) {
-    viewer_call(
+    return viewer_call(
       {
         schema: model_points_schemas.visibility,
         params: { id, visibility },
@@ -27,7 +27,7 @@ export function useModelPointsStyle() {
   }
 
   function setModelPointsSize(id, size) {
-    viewer_call(
+    return viewer_call(
       {
         schema: model_points_schemas.size,
         params: { id, size },

package/internal_stores/model/surfaces.js

@@ -14,7 +14,7 @@ export function useSurfacesStyle() {
   /** Actions **/
   function setSurfaceVisibility(id, surface_ids, visibility) {
     const surface_flat_indexes = dataBaseStore.getFlatIndexes(id, surface_ids)
-    viewer_call(
+    return viewer_call(
       {
         schema: surfaces_schemas.visibility,
         params: { id, block_ids: surface_flat_indexes, visibility },

package/package.json

@@ -2,16 +2,19 @@
   "name": "@geode/opengeodeweb-front",
   "scripts": {
     "lint": "eslint --fix --ext .js,.vue --ignore-path .gitignore .",
-    "test": "vitest",
-    "coverage": "vitest run --coverage",
+    "test": "npm run test:unit",
+    "tests": "vitest --config ./tests/vitest.config.js",
+    "test:unit": "npm run tests --project unit",
+    "test:integration": "npm run tests --project integration",
     "geode_objects": "node scripts/generate_geode_objects.js && prettier ./assets/geode_objects.js --write",
     "build": ""
   },
   "devDependencies": {
-    "@nuxt/test-utils": "3.18.0",
+    "@nuxt/test-utils": "3.19.2",
     "@pinia/testing": "0.1.7",
     "@vitejs/plugin-vue": "5.2.3",
     "@vue/test-utils": "2.4.6",
+    "electron": "36.4.0",
     "eslint": "9.26.0",
     "eslint-plugin-import": "2.31.0",
     "eslint-plugin-nuxt": "4.0.0",
@@ -21,13 +24,15 @@
     "eslint-plugin-vuetify": "2.5.2",
     "happy-dom": "17.4.6",
     "jsdom": "26.1.0",
+    "msw": "2.11.1",
     "nuxt": "3.13.2",
     "playwright-core": "1.52.0",
     "prettier": "3.3.3",
     "resize-observer-polyfill": "1.5.1",
+    "unplugin-auto-import": "^20.0.0",
     "vite": "6.3.5",
     "vite-plugin-vuetify": "2.1.1",
-    "vitest": "3.1.2",
+    "vitest": "3.2.4",
     "vitest-environment-nuxt": "1.0.1"
   },
   "overrides": {
@@ -35,7 +40,7 @@
   },
   "description": "OpenSource Vue/Vuetify framework for web applications",
   "type": "module",
-  "version": "9.11.2",
+  "version": "9.11.3-rc.3",
   "main": "./nuxt.config.js",
   "dependencies": {
     "@geode/opengeodeweb-back": "latest",
@@ -47,10 +52,12 @@
     "@vueuse/components": "13.1.0",
     "@vueuse/nuxt": "13.1.0",
     "ajv": "8.17.1",
+    "get-port-please": "3.2.0",
     "is-electron": "2.2.2",
     "js-file-download": "0.4.12",
     "nuxt": "3.13.2",
-    "pinia": "2.3.1",
+    "pidtree": "0.6.0",
+    "pinia": "3.0.3",
     "sass": "1.87.0",
     "semver": "7.7.1",
     "uuid": "11.1.0",

package/stores/data_base.js

@@ -1,7 +1,8 @@
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 
 export const useDataBaseStore = defineStore("dataBase", () => {
-  const treeview_store = use_treeview_store()
+  const treeview_store = useTreeviewStore()
   const hybridViewerStore = useHybridViewerStore()
 
   /** State **/
@@ -41,6 +42,12 @@ export const useDataBaseStore = defineStore("dataBase", () => {
   }
 
   /** Actions **/
+  async function registerObject(id, file_name, viewer_object) {
+    return viewer_call({
+      schema: viewer_schemas.opengeodeweb_viewer.generic.register,
+      params: { id, file_name, viewer_object },
+    })
+  }
   async function addItem(
     id,
     value = {
@@ -137,6 +144,7 @@ export const useDataBaseStore = defineStore("dataBase", () => {
     itemMetaDatas,
     meshComponentType,
     formatedMeshComponents,
+    registerObject,
     addItem,
     fetchUuidToFlatIndexDict,
     fetchMeshComponents,

package/stores/data_style.js

@@ -12,21 +12,22 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
   /** Actions **/
   function addDataStyle(id, geode_object, object_type) {
     dataStyleState.styles[id] = getDefaultStyle(geode_object)
-
     if (object_type === "mesh") {
-      meshStyleStore.applyMeshDefaultStyle(id)
+      return Promise.all([meshStyleStore.applyMeshDefaultStyle(id)])
     } else if (object_type === "model") {
-      modelStyleStore.setMeshComponentsDefaultStyle(id)
-      modelStyleStore.applyModelDefaultStyle(id)
+      return Promise.all([
+        modelStyleStore.setMeshComponentsDefaultStyle(id),
+        modelStyleStore.applyModelDefaultStyle(id),
+      ])
     }
   }
 
   function setVisibility(id, visibility) {
     const object_type = dataBaseStore.itemMetaDatas(id).object_type
     if (object_type === "mesh") {
-      meshStyleStore.setMeshVisibility(id, visibility)
+      return Promise.all([meshStyleStore.setMeshVisibility(id, visibility)])
     } else if (object_type === "model") {
-      modelStyleStore.setModelVisibility(id, visibility)
+      return Promise.all([modelStyleStore.setModelVisibility(id, visibility)])
     }
   }
 

package/stores/feedback.js

@@ -1,6 +1,6 @@
 import { v4 as uuidv4 } from "uuid"
 
-export const use_feedback_store = defineStore("feedback", {
+export const useFeedbackStore = defineStore("feedback", {
   state: () => ({
     feedbacks: [],
     server_error: false,

package/stores/geode.js

@@ -1,7 +1,7 @@
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
 import Status from "@ogw_f/utils/status.js"
 
-export const use_geode_store = defineStore("geode", {
+export const useGeodeStore = defineStore("geode", {
   state: () => ({
     default_local_port: "5000",
     request_counter: 0,
@@ -9,13 +9,13 @@ export const use_geode_store = defineStore("geode", {
   }),
   getters: {
     protocol() {
-      if (use_infra_store().app_mode == appMode.appMode.CLOUD) {
+      if (useInfraStore().app_mode == appMode.appMode.CLOUD) {
         return "https"
       }
       return "http"
     },
     port() {
-      if (use_infra_store().app_mode == appMode.appMode.CLOUD) {
+      if (useInfraStore().app_mode == appMode.appMode.CLOUD) {
         return "443"
       }
       const GEODE_PORT = useRuntimeConfig().public.GEODE_PORT
@@ -25,7 +25,7 @@ export const use_geode_store = defineStore("geode", {
       return this.default_local_port
     },
     base_url() {
-      const infra_store = use_infra_store()
+      const infra_store = useInfraStore()
       let geode_url = `${this.protocol}://${infra_store.domain_name}:${this.port}`
       if (infra_store.app_mode == appMode.appMode.CLOUD) {
         if (infra_store.ID == "") {
@@ -49,7 +49,7 @@ export const use_geode_store = defineStore("geode", {
     },
     do_ping() {
       const geode_store = this
-      const feedback_store = use_feedback_store()
+      const feedback_store = useFeedbackStore()
       return useFetch(back_schemas.opengeodeweb_back.ping.$id, {
         baseURL: this.base_url,
         method: back_schemas.opengeodeweb_back.ping.methods[0],

package/stores/hybrid_viewer.js

@@ -8,7 +8,7 @@ import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schem
 import Status from "@ogw_f/utils/status.js"
 
 export const useHybridViewerStore = defineStore("hybridViewer", () => {
-  const viewer_store = use_viewer_store()
+  const viewer_store = useViewerStore()
   const db = reactive({})
   const status = ref(Status.NOT_CREATED)
   const camera_options = reactive({})