@geode/opengeodeweb-front 10.3.0 → 10.3.1

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

@@ -2,8 +2,8 @@
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 
 // Local imports
-import { useViewerStore } from "@ogw_front/stores/viewer"
 import { useMeshPolyhedraCommonStyle } from "./common"
+import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants
 const meshPolyhedraVisibilitySchema =

package/internal/stores/data_style/model/edges.js

@@ -38,7 +38,7 @@ export function useModelEdgesStyle() {
 
   function applyModelEdgesStyle(id) {
     const style = modelEdgesStyle(id)
-    return Promise.all([setModelEdgesVisibility(id, style.visibility)])
+    return Promise.resolve([setModelEdgesVisibility(id, style.visibility)])
   }
 
   return {

package/internal/stores/data_style/model/index.js

@@ -2,16 +2,16 @@
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 
 // Local imports
-import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer"
-import { useDataStyleStateStore } from "../state"
 import { useDataStore } from "@ogw_front/stores/data"
-import { useViewerStore } from "@ogw_front/stores/viewer"
-import { useModelSurfacesStyle } from "./surfaces"
-import { useModelCornersStyle } from "./corners"
+import { useDataStyleStateStore } from "../state"
+import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer"
 import { useModelBlocksStyle } from "./blocks"
-import { useModelLinesStyle } from "./lines"
+import { useModelCornersStyle } from "./corners"
 import { useModelEdgesStyle } from "./edges"
+import { useModelLinesStyle } from "./lines"
 import { useModelPointsStyle } from "./points"
+import { useModelSurfacesStyle } from "./surfaces"
+import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants
 const model_schemas = viewer_schemas.opengeodeweb_viewer.model
@@ -48,23 +48,33 @@ export default function useModelStyle() {
   function visibleMeshComponents(id) {
     const visible_mesh_components = ref([])
     const styles = dataStyleStateStore.styles[id]
-    if (!styles) return visible_mesh_components
+    if (!styles) {
+      return visible_mesh_components
+    }
 
-    Object.entries(styles.corners || {}).forEach(([corner_id, style]) => {
-      if (style.visibility) visible_mesh_components.value.push(corner_id)
-    })
+    for (const [corner_id, style] of Object.entries(styles.corners || {})) {
+      if (style.visibility) {
+        visible_mesh_components.value.push(corner_id)
+      }
+    }
 
-    Object.entries(styles.lines || {}).forEach(([line_id, style]) => {
-      if (style.visibility) visible_mesh_components.value.push(line_id)
-    })
+    for (const [line_id, style] of Object.entries(styles.lines || {})) {
+      if (style.visibility) {
+        visible_mesh_components.value.push(line_id)
+      }
+    }
 
-    Object.entries(styles.surfaces || {}).forEach(([surface_id, style]) => {
-      if (style.visibility) visible_mesh_components.value.push(surface_id)
-    })
+    for (const [surface_id, style] of Object.entries(styles.surfaces || {})) {
+      if (style.visibility) {
+        visible_mesh_components.value.push(surface_id)
+      }
+    }
 
-    Object.entries(styles.blocks || {}).forEach(([block_id, style]) => {
-      if (style.visibility) visible_mesh_components.value.push(block_id)
-    })
+    for (const [block_id, style] of Object.entries(styles.blocks || {})) {
+      if (style.visibility) {
+        visible_mesh_components.value.push(block_id)
+      }
+    }
 
     return visible_mesh_components
   }
@@ -79,7 +89,7 @@ export default function useModelStyle() {
     } else if (component_type === "Block") {
       return modelBlocksStyleStore.modelBlockVisibility(id, component_id)
     }
-    throw new Error("Unknown model component_type: " + component_type)
+    throw new Error(`Unknown model component_type: ${component_type}`)
   }
 
   function modelColor(id) {
@@ -132,7 +142,7 @@ export default function useModelStyle() {
         visibility,
       )
     } else {
-      throw new Error("Unknown model component_type: " + component_type)
+      throw new Error(`Unknown model component_type: ${component_type}`)
     }
   }
 
@@ -155,7 +165,7 @@ export default function useModelStyle() {
       } else if (key === "edges") {
         promise_array.push(modelEdgesStyleStore.applyModelEdgesStyle(id))
       } else {
-        throw new Error("Unknown model key: " + key)
+        throw new Error(`Unknown model key: ${key}`)
       }
     }
     return Promise.all(promise_array)

package/internal/utils/api_fetch.js

@@ -1,6 +1,9 @@
+// oxlint-disable-next-line id-length
 import _ from "lodash"
-import validate_schema from "@ogw_front/utils/validate_schema"
 import { useFeedbackStore } from "@ogw_front/stores/feedback"
+import validate_schema from "@ogw_front/utils/validate_schema"
+
+const ERROR_400 = 400
 
 export function api_fetch(
   microservice,
@@ -17,15 +20,15 @@ export function api_fetch(
     if (process.env.NODE_ENV !== "production") {
       console.log("Bad request", error, schema, params)
     }
-    feedbackStore.add_error(400, schema.$id, "Bad request", error)
-    throw new Error(schema.$id.concat(": ", error))
+    feedbackStore.add_error(ERROR_400, schema.$id, "Bad request", error)
+    throw new Error(`${schema.$id}: ${error}`)
   }
 
   microservice.start_request()
 
-  const method = schema.methods.filter((method) => method !== "OPTIONS")[0]
+  const method = schema.methods.find((methodItem) => methodItem !== "OPTIONS")
   const request_options = {
-    method: method,
+    method,
   }
   if (!_.isEmpty(body)) {
     request_options.body = body

package/internal/utils/viewer_call.js

@@ -1,7 +1,10 @@
-import validate_schema from "@ogw_front/utils/validate_schema"
+import pTimeout from "p-timeout"
 import { useFeedbackStore } from "@ogw_front/stores/feedback"
+import validate_schema from "@ogw_front/utils/validate_schema"
 
-export function viewer_call(
+const ERROR_400 = 400
+
+export async function viewer_call(
   microservice,
   { schema, params = {} },
   {
@@ -19,61 +22,54 @@ export function viewer_call(
     if (process.env.NODE_ENV !== "production") {
       console.log("Bad request", error, schema, params)
     }
-    feedbackStore.add_error(400, schema.$id, "Bad request", error)
-    throw new Error(schema.$id.concat(": ", error))
+    feedbackStore.add_error(ERROR_400, schema.$id, "Bad request", error)
+    throw new Error(`${schema.$id}: ${error}`)
   }
 
-  const client = microservice.client
+  const { client } = microservice
 
-  const promise = new Promise((resolve, reject) => {
+  async function performCall() {
     if (!client.getConnection) {
-      resolve()
       return
     }
     microservice.start_request()
 
-    client
-      .getConnection()
-      .getSession()
-      .call(schema.$id, [params])
-      .then(
-        (value) => {
-          if (response_function) {
-            response_function(value)
-          }
-          resolve()
-        },
-        (reason) => {
-          if (request_error_function) {
-            request_error_function(reason)
-          }
-          reject()
-        },
+    try {
+      const value = await client
+        .getConnection()
+        .getSession()
+        .call(schema.$id, [params])
+      if (response_function) {
+        response_function(value)
+      }
+      return value
+    } catch (error) {
+      feedbackStore.add_error(
+        error.code,
+        schema.$id,
+        error.message,
+        error.message,
       )
-      .catch((error) => {
-        feedbackStore.add_error(
-          error.code,
-          schema.$id,
-          error.message,
-          error.message,
-        )
-        if (response_error_function) {
-          response_error_function(error)
-        }
-        reject()
-      })
-      .finally(() => {
-        microservice.stop_request()
-      })
-  })
+      if (request_error_function) {
+        request_error_function(error)
+      }
+      if (response_error_function) {
+        response_error_function(error)
+      }
+      throw error
+    } finally {
+      microservice.stop_request()
+    }
+  }
+
   if (timeout !== undefined && timeout > 0) {
-    const timeoutPromise = setTimeout(() => {
-      reject(`${schema.$id}: Timed out after ${timeout}ms, ${schema} ${params}`)
-    }, timeout)
-    return Promise.race([promise, timeoutPromise])
-  } else {
-    return promise
+    return await pTimeout(performCall(), {
+      milliseconds: timeout,
+      message: `${schema.$id}: Timed out after ${timeout}ms`,
+    })
   }
+
+  return await performCall()
 }
 
 export default viewer_call

package/nuxt.config.js

@@ -6,8 +6,8 @@ export default defineNuxtConfig({
         process.env.NODE_ENV === "production" ? process.env.SITE_BRANCH : "",
       PROJECT: process.env.NODE_ENV === "production" ? process.env.PROJECT : "",
       BROWSER: process.env.BROWSER ?? false,
-      GEODE_PORT: process.env.GEODE_PORT ?? null,
-      VIEWER_PORT: process.env.VIEWER_PORT ?? null,
+      GEODE_PORT: process.env.GEODE_PORT ?? undefined,
+      VIEWER_PORT: process.env.VIEWER_PORT ?? undefined,
     },
   },
 
@@ -20,7 +20,7 @@ export default defineNuxtConfig({
   },
 
   alias: {
-    "@ogw_front": __dirname + "/app/",
+    "@ogw_front": `${__dirname}/app/`,
   },
 
   // ** Global CSS

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.0",
+  "version": "10.3.1",
   "main": "./nuxt.config.js",
   "scripts": {
     "lint": "eslint --fix --ext .js,.vue --ignore-path .gitignore .",

package/scripts/generate_geode_objects.js

@@ -1,6 +1,7 @@
-import * as path from "path"
-import * as fs from "fs"
-import * as process from "process"
+// oxlint-disable-next-line id-length
+import fs from "node:fs"
+import path from "node:path"
+import process from "node:process"
 
 const output_file = path.join(process.cwd(), "assets/geode_objects")
 
@@ -8,9 +9,9 @@ if (fs.existsSync(output_file)) {
   fs.unlinkSync(output_file)
 }
 
-var files = fs.readdirSync("assets/img/geode_objects/")
-var imports = ""
-var geode_objects = "const geode_objects = {"
+const files = fs.readdirSync("assets/img/geode_objects/")
+let imports = ""
+let geode_objects = "const geode_objects = {"
 
 for (const file of files) {
   const geode_object = file.replace(".svg", "")
@@ -20,6 +21,6 @@ for (const file of files) {
   geode_objects += `${geode_object}:{\n tooltip: "${geode_object}",\n image: ${geode_object},\n},\n`
 }
 geode_objects += "}\n\n export default geode_objects"
-fs.writeFileSync(output_file, imports + "\n" + geode_objects)
+fs.writeFileSync(output_file, `${imports}\n${geode_objects}`)
 
 console.log("Fichier JS créé avec succès :", output_file)

package/tests/integration/setup.js

@@ -1,26 +1,28 @@
 // Node.js imports
-import path from "path"
-import { v4 as uuidv4 } from "uuid"
 import { WebSocket } from "ws"
+import path from "node:path"
+import { v4 as uuidv4 } from "uuid"
 
 // Third party imports
-import { setActivePinia } from "pinia"
-import { createTestingPinia } from "@pinia/testing"
 import { afterAll, beforeAll, expect, vi } from "vitest"
 
 // Local imports
-import { useGeodeStore } from "@ogw_front/stores/geode"
-import { useViewerStore } from "@ogw_front/stores/viewer"
-import { useInfraStore } from "@ogw_front/stores/infra"
-import { appMode } from "@ogw_front/utils/app_mode"
-import { importFile } from "@ogw_front/utils/file_import_workflow"
-import Status from "@ogw_front/utils/status"
 import {
+  delete_folder_recursive,
   executable_name,
   executable_path,
+  kill_back,
+  kill_viewer,
   run_back,
   run_viewer,
 } from "@ogw_front/utils/local"
+import Status from "@ogw_front/utils/status"
+import { appMode } from "@ogw_front/utils/app_mode"
+import { importFile } from "@ogw_front/utils/file_import_workflow"
+import { setupActivePinia } from "../utils"
+import { useGeodeStore } from "@ogw_front/stores/geode"
+import { useInfraStore } from "@ogw_front/stores/infra"
+import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants
 const data_folder = path.join("tests", "integration", "data")
@@ -60,11 +62,7 @@ async function runMicroservices() {
 }
 
 async function setupIntegrationTests(file_name, geode_object) {
-  const pinia = createTestingPinia({
-    stubActions: false,
-    createSpy: vi.fn,
-  })
-  setActivePinia(pinia)
+  setupActivePinia()
   const viewerStore = useViewerStore()
 
   const { back_port, viewer_port, project_folder_path } =
@@ -77,9 +75,9 @@ async function setupIntegrationTests(file_name, geode_object) {
   return { id, back_port, viewer_port, project_folder_path }
 }
 
-const mockLockRequest = vi.fn().mockImplementation(async (name, callback) => {
-  return callback({ name })
-})
+const mockLockRequest = vi
+  .fn()
+  .mockImplementation(async (name, task) => await task({ name }))
 
 vi.stubGlobal("navigator", {
   ...navigator,
@@ -89,11 +87,20 @@ vi.stubGlobal("navigator", {
 })
 
 beforeAll(() => {
-  global.WebSocket = WebSocket
+  globalThis.WebSocket = WebSocket
 })
 
 afterAll(() => {
-  delete global.WebSocket
+  delete globalThis.WebSocket
 })
 
-export { runMicroservices, setupIntegrationTests }
+async function teardownIntegrationTests(
+  back_port,
+  viewer_port,
+  project_folder_path,
+) {
+  await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+  delete_folder_recursive(project_folder_path)
+}
+
+export { runMicroservices, setupIntegrationTests, teardownIntegrationTests }

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

@@ -3,29 +3,33 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import Status from "@ogw_front/utils/status"
-import { useDataStyleStore } from "@ogw_front/stores/data_style"
-import { useViewerStore } from "@ogw_front/stores/viewer"
 import {
   delete_folder_recursive,
   kill_back,
   kill_viewer,
 } from "@ogw_front/utils/local"
+import Status from "@ogw_front/utils/status"
 import { setupIntegrationTests } from "../../../setup"
+import { useDataStyleStore } from "@ogw_front/stores/data_style"
+import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants
+const INTERVAL_TIMEOUT = 20_000
 const mesh_cells_schemas = viewer_schemas.opengeodeweb_viewer.mesh.cells
 const file_name = "test.og_rgd2d"
 const geode_object = "RegularGrid2D"
 const vertex_attribute = { name: "points" }
 const cell_attribute = { name: "RGB_data" }
 
-let id, back_port, viewer_port, project_folder_path
+let back_port = 0,
+  id = "",
+  project_folder_path = "",
+  viewer_port = 0
 
 beforeEach(async () => {
   ;({ id, back_port, viewer_port, project_folder_path } =
     await setupIntegrationTests(file_name, geode_object))
-}, 20000)
+}, INTERVAL_TIMEOUT)
 
 afterEach(async () => {
   console.log(
@@ -155,21 +159,25 @@ describe("Mesh cells", () => {
             ),
         },
       ]
-      for (let i = 0; i < coloringTypes.length; i++) {
-        if (coloringTypes[i].function) {
-          await coloringTypes[i].function()
+      async function testColoring(coloringType, expectedColoringType) {
+        if (coloringType.function) {
+          await coloringType.function()
         }
         const result = dataStyleStore.setMeshCellsActiveColoring(
           id,
-          coloringTypes[i].name,
+          coloringType.name,
         )
         expect(result).toBeInstanceOf(Promise)
         await result
         expect(dataStyleStore.meshCellsActiveColoring(id)).toBe(
-          coloringTypes[i].name,
+          expectedColoringType,
         )
         expect(viewerStore.status).toBe(Status.CONNECTED)
       }
+
+      await testColoring(coloringTypes[0], "color")
+      await testColoring(coloringTypes[1], "vertex")
+      await testColoring(coloringTypes[2], "cell")
     })
   })
 

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

@@ -3,29 +3,33 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import Status from "@ogw_front/utils/status"
-import { useDataStyleStore } from "@ogw_front/stores/data_style"
-import { useViewerStore } from "@ogw_front/stores/viewer"
 import {
   delete_folder_recursive,
   kill_back,
   kill_viewer,
 } from "@ogw_front/utils/local"
+import Status from "@ogw_front/utils/status"
 import { setupIntegrationTests } from "../../../setup"
+import { useDataStyleStore } from "@ogw_front/stores/data_style"
+import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants
+const INTERVAL_TIMEOUT = 25_000
 const mesh_edges_schemas = viewer_schemas.opengeodeweb_viewer.mesh.edges
 const file_name = "test.og_edc3d"
 const geode_object = "EdgedCurve3D"
 const vertex_attribute = { name: "vertex_attribute" }
 const edge_attribute = { name: "edge_attribute" }
 
-let id, back_port, viewer_port, project_folder_path
+let back_port = 0,
+  id = "",
+  project_folder_path = "",
+  viewer_port = 0
 
 beforeEach(async () => {
   ;({ id, back_port, viewer_port, project_folder_path } =
     await setupIntegrationTests(file_name, geode_object))
-}, 25000)
+}, INTERVAL_TIMEOUT)
 
 afterEach(async () => {
   console.log(
@@ -144,21 +148,25 @@ describe("Mesh edges", () => {
             ),
         },
       ]
-      for (let i = 0; i < coloringTypes.length; i++) {
-        if (coloringTypes[i].function) {
-          await coloringTypes[i].function()
+      async function testColoring(coloringType) {
+        if (coloringType.function) {
+          await coloringType.function()
         }
         const result = dataStyleStore.setMeshEdgesActiveColoring(
           id,
-          coloringTypes[i].name,
+          coloringType.name,
         )
         expect(result).toBeInstanceOf(Promise)
         await result
         expect(dataStyleStore.meshEdgesActiveColoring(id)).toBe(
-          coloringTypes[i].name,
+          coloringType.name,
         )
         expect(viewerStore.status).toBe(Status.CONNECTED)
       }
+
+      await testColoring(coloringTypes[0])
+      await testColoring(coloringTypes[1])
+      await testColoring(coloringTypes[2])
     })
     test("Edges apply style", async () => {
       const dataStyleStore = useDataStyleStore()

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

@@ -3,27 +3,31 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import Status from "@ogw_front/utils/status"
-import { useDataStyleStore } from "@ogw_front/stores/data_style"
-import { useViewerStore } from "@ogw_front/stores/viewer"
 import {
   delete_folder_recursive,
   kill_back,
   kill_viewer,
 } from "@ogw_front/utils/local"
+import Status from "@ogw_front/utils/status"
 import { setupIntegrationTests } from "../../../setup"
+import { useDataStyleStore } from "@ogw_front/stores/data_style"
+import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants
+const INTERVAL_TIMEOUT = 20_000
 const mesh_schemas = viewer_schemas.opengeodeweb_viewer.mesh
 const file_name = "test.og_rgd3d"
 const geode_object = "RegularGrid3D"
 
-let id, back_port, viewer_port, project_folder_path
+let back_port = 0,
+  id = "",
+  project_folder_path = "",
+  viewer_port = 0
 
 beforeEach(async () => {
   ;({ id, back_port, viewer_port, project_folder_path } =
     await setupIntegrationTests(file_name, geode_object))
-}, 20000)
+}, INTERVAL_TIMEOUT)
 
 afterEach(async () => {
   console.log(

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

@@ -3,28 +3,32 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import Status from "@ogw_front/utils/status"
-import { useDataStyleStore } from "@ogw_front/stores/data_style"
-import { useViewerStore } from "@ogw_front/stores/viewer"
 import {
   delete_folder_recursive,
   kill_back,
   kill_viewer,
 } from "@ogw_front/utils/local"
+import Status from "@ogw_front/utils/status"
 import { setupIntegrationTests } from "../../../setup"
+import { useDataStyleStore } from "@ogw_front/stores/data_style"
+import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants
+const INTERVAL_TIMEOUT = 20_000
 const mesh_points_schemas = viewer_schemas.opengeodeweb_viewer.mesh.points
 const file_name = "test.og_edc2d"
 const geode_object = "EdgedCurve2D"
 const vertex_attribute = { name: "points" }
 
-let id, back_port, viewer_port, project_folder_path
+let back_port = 0,
+  id = "",
+  project_folder_path = "",
+  viewer_port = 0
 
 beforeEach(async () => {
   ;({ id, back_port, viewer_port, project_folder_path } =
     await setupIntegrationTests(file_name, geode_object))
-}, 20000)
+}, INTERVAL_TIMEOUT)
 
 afterEach(async () => {
   console.log(
@@ -95,21 +99,24 @@ describe("Mesh points", () => {
             ),
         },
       ]
-      for (let i = 0; i < coloringTypes.length; i++) {
-        if (coloringTypes[i].function) {
-          await coloringTypes[i].function()
+      async function testColoring(coloringType, expectedColoringType) {
+        if (coloringType.function) {
+          await coloringType.function()
         }
         const result = dataStyleStore.setMeshPointsActiveColoring(
           id,
-          coloringTypes[i].name,
+          coloringType.name,
         )
         expect(result).toBeInstanceOf(Promise)
         await result
         expect(dataStyleStore.meshPointsActiveColoring(id)).toBe(
-          coloringTypes[i].name,
+          expectedColoringType,
         )
         expect(viewerStore.status).toBe(Status.CONNECTED)
       }
+
+      await testColoring(coloringTypes[0], "color")
+      await testColoring(coloringTypes[1], "vertex")
     })
   })