@geode/opengeodeweb-front 10.0.2-rc.1 → 10.0.2-rc.3

package/{internal_stores → internal/stores}/mesh/points.js

@@ -16,8 +16,10 @@ export function useMeshPointsStyle() {
   }
   function setMeshPointsVisibility(id, visibility) {
     const points_style = meshPointsStyle(id)
-    return viewer_call(
-      { schema: mesh_points_schemas.visibility, params: { id, visibility } },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_points_schemas.visibility,
+      { id, visibility },
       {
         response_function: () => {
           points_style.visibility = visibility
@@ -56,8 +58,10 @@ export function useMeshPointsStyle() {
   }
   function setMeshPointsColor(id, color) {
     const coloring_style = meshPointsStyle(id).coloring
-    return viewer_call(
-      { schema: mesh_points_schemas.color, params: { id, color } },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_points_schemas.color,
+      { id, color },
       {
         response_function: () => {
           coloring_style.color = color
@@ -75,11 +79,10 @@ export function useMeshPointsStyle() {
   }
   function setMeshPointsVertexAttribute(id, vertex_attribute) {
     const coloring_style = meshPointsStyle(id).coloring
-    return viewer_call(
-      {
-        schema: mesh_points_schemas.vertex_attribute,
-        params: { id, ...vertex_attribute },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_points_schemas.vertex_attribute,
+      { id, ...vertex_attribute },
       {
         response_function: () => {
           coloring_style.vertex = vertex_attribute
@@ -97,8 +100,10 @@ export function useMeshPointsStyle() {
     return meshPointsStyle(id).size
   }
   function setMeshPointsSize(id, size) {
-    return viewer_call(
-      { schema: mesh_points_schemas.size, params: { id, size } },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_points_schemas.size,
+      { id, size },
       {
         response_function: () => {
           meshPointsStyle(id).size = size

package/{internal_stores → internal/stores}/mesh/polygons.js

@@ -16,8 +16,10 @@ export function useMeshPolygonsStyle() {
   }
   function setMeshPolygonsVisibility(id, visibility) {
     const polygons_style = meshPolygonsStyle(id)
-    return viewer_call(
-      { schema: mesh_polygons_schemas.visibility, params: { id, visibility } },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_polygons_schemas.visibility,
+      { id, visibility },
       {
         response_function: () => {
           polygons_style.visibility = visibility
@@ -36,8 +38,10 @@ export function useMeshPolygonsStyle() {
   }
   function setMeshPolygonsColor(id, color) {
     const coloring_style = meshPolygonsStyle(id).coloring
-    return viewer_call(
-      { schema: mesh_polygons_schemas.color, params: { id, color } },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_polygons_schemas.color,
+      { id, color },
       {
         response_function: () => {
           coloring_style.color = color
@@ -56,11 +60,10 @@ export function useMeshPolygonsStyle() {
   }
   function setMeshPolygonsTextures(id, textures) {
     const coloring_style = meshPolygonsStyle(id).coloring
-    return viewer_call(
-      {
-        schema: mesh_polygons_schemas.apply_textures,
-        params: { id, textures },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_polygons_schemas.apply_textures,
+      { id, textures },
       {
         response_function: () => {
           coloring_style.textures = textures
@@ -80,11 +83,10 @@ export function useMeshPolygonsStyle() {
 
   function setMeshPolygonsVertexAttribute(id, vertex_attribute) {
     const coloring_style = meshPolygonsStyle(id).coloring
-    return viewer_call(
-      {
-        schema: mesh_polygons_schemas.vertex_attribute,
-        params: { id, ...vertex_attribute },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_polygons_schemas.vertex_attribute,
+      { id, ...vertex_attribute },
       {
         response_function: () => {
           coloring_style.vertex = vertex_attribute
@@ -103,11 +105,10 @@ export function useMeshPolygonsStyle() {
   }
   function setMeshPolygonsPolygonAttribute(id, polygon_attribute) {
     const coloring_style = meshPolygonsStyle(id).coloring
-    return viewer_call(
-      {
-        schema: mesh_polygons_schemas.polygon_attribute,
-        params: { id, ...polygon_attribute },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_polygons_schemas.polygon_attribute,
+      { id, ...polygon_attribute },
       {
         response_function: () => {
           coloring_style.polygon = polygon_attribute

package/{internal_stores → internal/stores}/mesh/polyhedra.js

@@ -16,8 +16,10 @@ export function useMeshPolyhedraStyle() {
   }
   function setMeshPolyhedraVisibility(id, visibility) {
     const polyhedra_style = meshPolyhedraStyle(id)
-    return viewer_call(
-      { schema: mesh_polyhedra_schemas.visibility, params: { id, visibility } },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_polyhedra_schemas.visibility,
+      { id, visibility },
       {
         response_function: () => {
           polyhedra_style.visibility = visibility
@@ -57,8 +59,10 @@ export function useMeshPolyhedraStyle() {
   }
   function setMeshPolyhedraColor(id, color) {
     const coloring = meshPolyhedraStyle(id).coloring
-    return viewer_call(
-      { schema: mesh_polyhedra_schemas.color, params: { id, color } },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_polyhedra_schemas.color,
+      { id, color },
       {
         response_function: () => {
           coloring.color = color
@@ -77,11 +81,9 @@ export function useMeshPolyhedraStyle() {
   // }
   // function setPolyhedraVertexAttribute(id, vertex_attribute) {
   //   const coloring_style = meshPolyhedraStyle(id).coloring
-  //   return viewer_call(
-  //     {
-  //       schema: mesh_polyhedra_schemas.vertex_attribute,
-  //       params: { id, ...vertex_attribute },
-  //     },
+  //   return viewerStore.request(
+  //     mesh_polyhedra_schemas.vertex_attribute,
+  //     { id, ...vertex_attribute },
   //     {
   //       response_function: () => {
   //         coloring_style.vertex = vertex_attribute
@@ -98,11 +100,9 @@ export function useMeshPolyhedraStyle() {
   // }
   // function setPolyhedraPolygonAttribute(id, polygon_attribute) {
   //   const coloring_style = meshPolyhedraStyle(id).coloring
-  //   return viewer_call(
-  //     {
-  //       schema: mesh_polyhedra_schemas.polygon_attribute,
-  //       params: { id, ...polygon_attribute },
-  //     },
+  //   return viewerStore.request(
+  //     mesh_polyhedra_schemas.polygon_attribute,
+  //     { id, ...polygon_attribute },
   //     {
   //       response_function: () => {
   //         coloring_style.polygon = polygon_attribute
@@ -119,11 +119,9 @@ export function useMeshPolyhedraStyle() {
   // }
   // function setPolyhedraPolyhedronAttribute(id, polyhedron_attribute) {
   //   const coloring = meshPolyhedraStyle(id).coloring
-  //   return viewer_call(
-  //     {
-  //       schema: mesh_polyhedra_schemas.polyhedron_attribute,
-  //       params: { id, ...polyhedron_attribute },
-  //     },
+  //   return viewerStore.request(
+  //     mesh_polyhedra_schemas.polyhedron_attribute,
+  //     { id, ...polyhedron_attribute },
   //     {
   //       response_function: () => {
   //         coloring.polyhedron = polyhedron_attribute

package/{internal_stores → internal/stores}/model/blocks.js

@@ -27,11 +27,10 @@ export function useModelBlocksStyle() {
   }
   function setModelBlocksVisibility(id, block_ids, visibility) {
     const blocks_flat_indexes = dataBaseStore.getFlatIndexes(id, block_ids)
-    return viewer_call(
-      {
-        schema: model_blocks_schemas.visibility,
-        params: { id, block_ids: blocks_flat_indexes, visibility },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      model_blocks_schemas.visibility,
+      { id, block_ids: blocks_flat_indexes, visibility },
       {
         response_function: () => {
           for (const block_id of block_ids) {
@@ -57,11 +56,10 @@ export function useModelBlocksStyle() {
 
   function setModelBlocksColor(id, block_ids, color) {
     const blocks_flat_indexes = dataBaseStore.getFlatIndexes(id, block_ids)
-    return viewer_call(
-      {
-        schema: model_blocks_schemas.color,
-        params: { id, block_ids: blocks_flat_indexes, color },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      model_blocks_schemas.color,
+      { id, block_ids: blocks_flat_indexes, color },
       {
         response_function: () => {
           for (const block_id of block_ids) {

package/{internal_stores → internal/stores}/model/corners.js

@@ -27,11 +27,10 @@ export function useModelCornersStyle() {
   }
   function setModelCornersVisibility(id, corner_ids, visibility) {
     const corner_flat_indexes = dataBaseStore.getFlatIndexes(id, corner_ids)
-    return viewer_call(
-      {
-        schema: model_corners_schemas.visibility,
-        params: { id, block_ids: corner_flat_indexes, visibility },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      model_corners_schemas.visibility,
+      { id, block_ids: corner_flat_indexes, visibility },
       {
         response_function: () => {
           for (const corner_id of corner_ids) {
@@ -58,11 +57,10 @@ export function useModelCornersStyle() {
 
   function setModelCornersColor(id, corner_ids, color) {
     const corner_flat_indexes = dataBaseStore.getFlatIndexes(id, corner_ids)
-    return viewer_call(
-      {
-        schema: model_corners_schemas.color,
-        params: { id, block_ids: corner_flat_indexes, color },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      model_corners_schemas.color,
+      { id, block_ids: corner_flat_indexes, color },
       {
         response_function: () => {
           for (const corner_id of corner_ids) {

package/{internal_stores → internal/stores}/model/edges.js

@@ -15,11 +15,10 @@ export function useModelEdgesStyle() {
   }
 
   function setModelEdgesVisibility(id, visibility) {
-    return viewer_call(
-      {
-        schema: model_edges_schemas.visibility,
-        params: { id, visibility },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      model_edges_schemas.visibility,
+      { id, visibility },
       {
         response_function: () => {
           modelEdgesStyle(id).visibility = visibility

package/{internal_stores → internal/stores}/model/index.js

@@ -27,11 +27,10 @@ export default function useModelStyle() {
     return dataStyleStore.getStyle(id).visibility
   }
   function setModelVisibility(id, visibility) {
-    return viewer_call(
-      {
-        schema: model_schemas.visibility,
-        params: { id, visibility },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      model_schemas.visibility,
+      { id, visibility },
       {
         response_function: () => {
           dataStyleStore.getStyle(id).visibility = visibility
@@ -83,11 +82,10 @@ export default function useModelStyle() {
     return dataStyleStore.getStyle(id).color
   }
   function setModelColor(id, color) {
-    return viewer_call(
-      {
-        schema: model_schemas.color,
-        params: { id, color },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      model_schemas.color,
+      { id, color },
       {
         response_function: () => {
           dataStyleStore.styles[id].color = color

package/{internal_stores → internal/stores}/model/lines.js

@@ -27,11 +27,10 @@ export function useModelLinesStyle() {
   }
   function setModelLinesVisibility(id, line_ids, visibility) {
     const line_flat_indexes = dataBaseStore.getFlatIndexes(id, line_ids)
-    return viewer_call(
-      {
-        schema: model_lines_schemas.visibility,
-        params: { id, block_ids: line_flat_indexes, visibility },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      model_lines_schemas.visibility,
+      { id, block_ids: line_flat_indexes, visibility },
       {
         response_function: () => {
           for (const line_id of line_ids) {
@@ -56,11 +55,10 @@ export function useModelLinesStyle() {
   }
   function setModelLinesColor(id, line_ids, color) {
     const line_flat_indexes = dataBaseStore.getFlatIndexes(id, line_ids)
-    return viewer_call(
-      {
-        schema: model_lines_schemas.color,
-        params: { id, block_ids: line_flat_indexes, color },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      model_lines_schemas.color,
+      { id, block_ids: line_flat_indexes, color },
       {
         response_function: () => {
           for (const line_id of line_ids) {

package/{internal_stores → internal/stores}/model/points.js

@@ -14,11 +14,10 @@ export function useModelPointsStyle() {
     return modelPointsStyle(id).visibility
   }
   function setModelPointsVisibility(id, visibility) {
-    return viewer_call(
-      {
-        schema: model_points_schemas.visibility,
-        params: { id, visibility },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      model_points_schemas.visibility,
+      { id, visibility },
       {
         response_function: () => {
           modelPointsStyle(id).visibility = visibility
@@ -36,11 +35,10 @@ export function useModelPointsStyle() {
     return modelPointsStyle(id).size
   }
   function setModelPointsSize(id, size) {
-    return viewer_call(
-      {
-        schema: model_points_schemas.size,
-        params: { id, size },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      model_points_schemas.size,
+      { id, size },
       {
         response_function: () => {
           dataStyleStore.styles[id].points.size = size

package/{internal_stores → internal/stores}/model/surfaces.js

@@ -26,11 +26,10 @@ export function useModelSurfacesStyle() {
   }
   function setModelSurfacesVisibility(id, surface_ids, visibility) {
     const surface_flat_indexes = dataBaseStore.getFlatIndexes(id, surface_ids)
-    return viewer_call(
-      {
-        schema: model_surfaces_schemas.visibility,
-        params: { id, block_ids: surface_flat_indexes, visibility },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      model_surfaces_schemas.visibility,
+      { id, block_ids: surface_flat_indexes, visibility },
       {
         response_function: () => {
           for (const surface_id of surface_ids) {
@@ -55,11 +54,10 @@ export function useModelSurfacesStyle() {
 
   function setModelSurfacesColor(id, surface_ids, color) {
     const surface_flat_indexes = dataBaseStore.getFlatIndexes(id, surface_ids)
-    return viewer_call(
-      {
-        schema: model_surfaces_schemas.color,
-        params: { id, block_ids: surface_flat_indexes, color },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      model_surfaces_schemas.color,
+      { id, block_ids: surface_flat_indexes, color },
       {
         response_function: () => {
           for (const surface_id of surface_ids) {

package/{app/composables → internal/utils}/api_fetch.js

@@ -2,11 +2,11 @@ import _ from "lodash"
 import validate_schema from "@/app/utils/validate_schema.js"
 
 export function api_fetch(
+  microservice,
   { schema, params },
   { request_error_function, response_function, response_error_function } = {},
 ) {
-  const feedback_store = useFeedbackStore()
-  const geode_store = useGeodeStore()
+  const feedbackStore = useFeedbackStore()
 
   const body = params || {}
 
@@ -16,13 +16,13 @@ export function api_fetch(
     if (process.env.NODE_ENV !== "production") {
       console.log("Bad request", error, schema, params)
     }
-    feedback_store.add_error(400, schema.$id, "Bad request", error)
+    feedbackStore.add_error(400, schema.$id, "Bad request", error)
     throw new Error(schema.$id.concat(": ", error))
   }
 
-  geode_store.start_request()
+  microservice.start_request()
 
-  const method = schema.methods.filter((m) => m !== "OPTIONS")[0]
+  const method = schema.methods.filter((method) => method !== "OPTIONS")[0]
   const request_options = {
     method: method,
   }
@@ -34,11 +34,11 @@ export function api_fetch(
     request_options.max_retry = schema.max_retry
   }
   return useFetch(schema.$id, {
-    baseURL: geode_store.base_url,
+    baseURL: microservice.base_url,
     ...request_options,
     async onRequestError({ error }) {
-      await geode_store.stop_request()
-      await feedback_store.add_error(
+      await microservice.stop_request()
+      await feedbackStore.add_error(
         error.code,
         schema.$id,
         error.message,
@@ -50,15 +50,15 @@ export function api_fetch(
     },
     async onResponse({ response }) {
       if (response.ok) {
-        await geode_store.stop_request()
+        await microservice.stop_request()
         if (response_function) {
           await response_function(response)
         }
       }
     },
     async onResponseError({ response }) {
-      await geode_store.stop_request()
-      await feedback_store.add_error(
+      await microservice.stop_request()
+      await feedbackStore.add_error(
         response.status,
         schema.$id,
         response._data.name,

package/{app/composables → internal/utils}/viewer_call.js

@@ -1,11 +1,11 @@
 import validate_schema from "~/app/utils/validate_schema.js"
 
 export function viewer_call(
+  microservice,
   { schema, params = {} },
   { request_error_function, response_function, response_error_function } = {},
 ) {
   const feedback_store = useFeedbackStore()
-  const viewer_store = useViewerStore()
 
   const { valid, error } = validate_schema(schema, params)
 
@@ -14,17 +14,17 @@ export function viewer_call(
       console.log("Bad request", error, schema, params)
     }
     feedback_store.add_error(400, schema.$id, "Bad request", error)
-    throw new Error(schema.$id.concat(": "))
+    throw new Error(schema.$id.concat(": ", error))
   }
 
-  const client = viewer_store.client
+  const client = microservice.client
 
   return new Promise((resolve, reject) => {
     if (!client.getConnection) {
       resolve()
       return
     }
-    viewer_store.start_request()
+    microservice.start_request()
     client
       .getConnection()
       .getSession()
@@ -56,7 +56,7 @@ export function viewer_call(
         reject()
       })
       .finally(() => {
-        viewer_store.stop_request()
+        microservice.stop_request()
       })
   })
 }

package/nuxt.config.js

@@ -16,7 +16,7 @@ export default defineNuxtConfig({
     "@vueuse/nuxt",
   ],
   imports: {
-    dirs: ["app/stores", "app/composables"],
+    dirs: ["app/stores", "app/composables", "app/utils", "internal/utils"],
   },
 
   alias: {

package/package.json

@@ -39,7 +39,7 @@
   },
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "type": "module",
-  "version": "10.0.2-rc.1",
+  "version": "10.0.2-rc.3",
   "main": "./nuxt.config.js",
   "dependencies": {
     "@geode/opengeodeweb-back": "next",

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

@@ -9,7 +9,6 @@ import {
   kill_back,
   kill_viewer,
 } from "@ogw_front/utils/local"
-import * as composables from "@ogw_front/composables/viewer_call"
 import { setupIntegrationTests } from "../../../setup.js"
 
 // Local constants
@@ -42,13 +41,11 @@ describe("Mesh cells", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const visibility = true
-      const spy = vi.spyOn(composables, "viewer_call")
+      const spy = vi.spyOn(viewerStore, "request")
       await dataStyleStore.setMeshCellsVisibility(id, visibility)
       expect(spy).toHaveBeenCalledWith(
-        {
-          schema: mesh_cells_schemas.visibility,
-          params: { id, visibility },
-        },
+        mesh_cells_schemas.visibility,
+        { id, visibility },
         {
           response_function: expect.any(Function),
         },
@@ -63,13 +60,11 @@ describe("Mesh cells", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const color = { r: 255, g: 0, b: 0 }
-      const spy = vi.spyOn(composables, "viewer_call")
+      const spy = vi.spyOn(viewerStore, "request")
       await dataStyleStore.setMeshCellsColor(id, color)
       expect(spy).toHaveBeenCalledWith(
-        {
-          schema: mesh_cells_schemas.color,
-          params: { id, color },
-        },
+        mesh_cells_schemas.color,
+        { id, color },
         {
           response_function: expect.any(Function),
         },
@@ -84,13 +79,11 @@ describe("Mesh cells", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const vertex_attribute = { name: "points" }
-      const spy = vi.spyOn(composables, "viewer_call")
+      const spy = vi.spyOn(viewerStore, "request")
       await dataStyleStore.setMeshCellsVertexAttribute(id, vertex_attribute)
       expect(spy).toHaveBeenCalledWith(
-        {
-          schema: mesh_cells_schemas.vertex_attribute,
-          params: { id, ...vertex_attribute },
-        },
+        mesh_cells_schemas.vertex_attribute,
+        { id, ...vertex_attribute },
         {
           response_function: expect.any(Function),
         },
@@ -107,13 +100,11 @@ describe("Mesh cells", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const cell_attribute = { name: "RGB_data" }
-      const spy = vi.spyOn(composables, "viewer_call")
+      const spy = vi.spyOn(viewerStore, "request")
       await dataStyleStore.setMeshCellsCellAttribute(id, cell_attribute)
       expect(spy).toHaveBeenCalledWith(
-        {
-          schema: mesh_cells_schemas.cell_attribute,
-          params: { id, ...cell_attribute },
-        },
+        mesh_cells_schemas.cell_attribute,
+        { id, ...cell_attribute },
         {
           response_function: expect.any(Function),
         },

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

@@ -9,7 +9,6 @@ import {
   kill_back,
   kill_viewer,
 } from "@ogw_front/utils/local"
-import * as composables from "@ogw_front/composables/viewer_call"
 import { setupIntegrationTests } from "../../../setup.js"
 
 // Local constants
@@ -41,13 +40,11 @@ describe("Mesh edges", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const visibility = true
-      const spy = vi.spyOn(composables, "viewer_call")
+      const spy = vi.spyOn(viewerStore, "request")
       await dataStyleStore.setMeshEdgesVisibility(id, visibility)
       expect(spy).toHaveBeenCalledWith(
-        {
-          schema: mesh_edges_schemas.visibility,
-          params: { id, visibility },
-        },
+        mesh_edges_schemas.visibility,
+        { id, visibility },
         {
           response_function: expect.any(Function),
         },
@@ -62,13 +59,11 @@ describe("Mesh edges", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const color = { r: 255, g: 0, b: 0 }
-      const spy = vi.spyOn(composables, "viewer_call")
+      const spy = vi.spyOn(viewerStore, "request")
       await dataStyleStore.setMeshEdgesColor(id, color)
       expect(spy).toHaveBeenCalledWith(
-        {
-          schema: mesh_edges_schemas.color,
-          params: { id, color },
-        },
+        mesh_edges_schemas.color,
+        { id, color },
         {
           response_function: expect.any(Function),
         },