@geode/opengeodeweb-front 10.22.1-rc.1 → 10.22.1

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

@@ -6,7 +6,7 @@ import { useMeshPolyhedraCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshPolyhedraColorSchemas = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.color;
+const schema = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.color;
 
 export function useMeshPolyhedraColorStyle() {
   const viewerStore = useViewerStore();
@@ -16,9 +16,12 @@ export function useMeshPolyhedraColorStyle() {
     return meshPolyhedraCommonStyle.meshPolyhedraColoring(id).color;
   }
   function setMeshPolyhedraColor(id, color) {
+    const params = { id, color };
     return viewerStore.request(
-      meshPolyhedraColorSchemas,
-      { id, color },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () =>
           meshPolyhedraCommonStyle.mutateMeshPolyhedraColoring(id, {

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

@@ -10,6 +10,7 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 const meshPolyhedraPolyhedronAttributeSchemas =
   viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.attribute.polyhedron;
 
+// oxlint-disable-next-line max-lines-per-function
 function useMeshPolyhedraPolyhedronAttributeConfig() {
   const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle();
 
@@ -74,14 +75,19 @@ function useMeshPolyhedraPolyhedronAttributeConfig() {
   };
 }
 
+// oxlint-disable-next-line max-lines-per-function
 function useMeshPolyhedraPolyhedronAttributeActions() {
   const viewerStore = useViewerStore();
   const config = useMeshPolyhedraPolyhedronAttributeConfig();
 
   function setMeshPolyhedraPolyhedronAttributeName(id, name) {
+    const schema = meshPolyhedraPolyhedronAttributeSchemas.name;
+    const params = { id, name };
     return viewerStore.request(
-      meshPolyhedraPolyhedronAttributeSchemas.name,
-      { id, name },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () => {
           const updates = { name };
@@ -105,9 +111,10 @@ function useMeshPolyhedraPolyhedronAttributeActions() {
     const name = config.meshPolyhedraPolyhedronAttributeName(id);
     const points = getRGBPointsFromPreset(config.meshPolyhedraPolyhedronAttributeColorMap(id));
     if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const schema = meshPolyhedraPolyhedronAttributeSchemas.color_map;
+      const params = { id, points, minimum, maximum };
       return viewerStore.request(
-        meshPolyhedraPolyhedronAttributeSchemas.color_map,
-        { id, points, minimum, maximum },
+        { schema, params },
         {
           response_function: () =>
             config.setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, { minimum, maximum }),
@@ -126,9 +133,10 @@ function useMeshPolyhedraPolyhedronAttributeActions() {
     const points = getRGBPointsFromPreset(colorMap);
     const { minimum, maximum } = storedConfig;
     if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const schema = meshPolyhedraPolyhedronAttributeSchemas.color_map;
+      const params = { id, points, minimum, maximum };
       return viewerStore.request(
-        meshPolyhedraPolyhedronAttributeSchemas.color_map,
-        { id, points, minimum, maximum },
+        { schema, params },
         {
           response_function: () =>
             config.setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, { colorMap }),

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

@@ -10,6 +10,7 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 const meshPolyhedraVertexAttributeSchemas =
   viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.attribute.vertex;
 
+// oxlint-disable-next-line max-lines-per-function
 function useMeshPolyhedraVertexAttributeConfig() {
   const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle();
 
@@ -74,14 +75,19 @@ function useMeshPolyhedraVertexAttributeConfig() {
   };
 }
 
+// oxlint-disable-next-line max-lines-per-function
 function useMeshPolyhedraVertexAttributeActions() {
   const viewerStore = useViewerStore();
   const config = useMeshPolyhedraVertexAttributeConfig();
 
   function setMeshPolyhedraVertexAttributeName(id, name) {
+    const schema = meshPolyhedraVertexAttributeSchemas.name;
+    const params = { id, name };
     return viewerStore.request(
-      meshPolyhedraVertexAttributeSchemas.name,
-      { id, name },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () => {
           const updates = { name };
@@ -105,9 +111,10 @@ function useMeshPolyhedraVertexAttributeActions() {
     const name = config.meshPolyhedraVertexAttributeName(id);
     const points = getRGBPointsFromPreset(config.meshPolyhedraVertexAttributeColorMap(id));
     if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const schema = meshPolyhedraVertexAttributeSchemas.color_map;
+      const params = { id, points, minimum, maximum };
       return viewerStore.request(
-        meshPolyhedraVertexAttributeSchemas.color_map,
-        { id, points, minimum, maximum },
+        { schema, params },
         {
           response_function: () =>
             config.setMeshPolyhedraVertexAttributeStoredConfig(id, name, { minimum, maximum }),
@@ -126,9 +133,10 @@ function useMeshPolyhedraVertexAttributeActions() {
     const points = getRGBPointsFromPreset(colorMap);
     const { minimum, maximum } = storedConfig;
     if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const schema = meshPolyhedraVertexAttributeSchemas.color_map;
+      const params = { id, points, minimum, maximum };
       return viewerStore.request(
-        meshPolyhedraVertexAttributeSchemas.color_map,
-        { id, points, minimum, maximum },
+        { schema, params },
         {
           response_function: () =>
             config.setMeshPolyhedraVertexAttributeStoredConfig(id, name, { colorMap }),

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

@@ -6,7 +6,7 @@ import { useMeshPolyhedraCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshPolyhedraVisibilitySchema = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.visibility;
+const schema = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.visibility;
 
 export function useMeshPolyhedraVisibilityStyle() {
   const viewerStore = useViewerStore();
@@ -16,9 +16,12 @@ export function useMeshPolyhedraVisibilityStyle() {
     return meshPolyhedraCommonStyle.meshPolyhedraStyle(id).visibility;
   }
   function setMeshPolyhedraVisibility(id, visibility) {
+    const params = { id, visibility };
     return viewerStore.request(
-      meshPolyhedraVisibilitySchema,
-      { id, visibility },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () =>
           meshPolyhedraCommonStyle.mutateMeshPolyhedraStyle(id, {

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

@@ -81,26 +81,29 @@ export function useModelCommonStyle() {
       params.color = color;
     }
 
-    return viewerStore.request(schema, params, {
-      response_function: async (colors) => {
-        if (color_mode === "constant" && color !== undefined) {
-          await mutateComponentStyles(id, component_ids, { color });
-          return;
-        }
-
-        if (!colors?.length) {
-          return;
-        }
-
-        await bulkMutateComponentStylesPerComponent(
-          id,
-          colors.map(({ geode_id, color: color_value }) => ({
-            id_component: geode_id,
-            values: { color: color_value },
-          })),
-        );
+    return viewerStore.request(
+      { schema, params },
+      {
+        response_function: async (colors) => {
+          if (color_mode === "constant" && color !== undefined) {
+            await mutateComponentStyles(id, component_ids, { color });
+            return;
+          }
+
+          if (!colors?.length) {
+            return;
+          }
+
+          await bulkMutateComponentStylesPerComponent(
+            id,
+            colors.map(({ geode_id, color: color_value }) => ({
+              id_component: geode_id,
+              values: { color: color_value },
+            })),
+          );
+        },
       },
-    });
+    );
   }
 
   async function setModelTypeVisibility(id, component_ids, visibility, schema) {
@@ -112,10 +115,9 @@ export function useModelCommonStyle() {
     if (!viewer_ids?.length) {
       return;
     }
-
+    const params = { id, block_ids: viewer_ids, visibility };
     return viewerStore.request(
-      schema,
-      { id, block_ids: viewer_ids, visibility },
+      { schema, params },
       {
         response_function: () => mutateComponentStyles(id, component_ids, { visibility }),
       },

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

@@ -5,7 +5,7 @@ import { useModelEdgesCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const model_edges_schemas = viewer_schemas.opengeodeweb_viewer.model.edges;
+const schema = viewer_schemas.opengeodeweb_viewer.model.edges.visibility;
 
 export function useModelEdgesVisibilityStyle() {
   const viewerStore = useViewerStore();
@@ -16,9 +16,9 @@ export function useModelEdgesVisibilityStyle() {
   }
 
   function setModelEdgesVisibility(id, visibility) {
+    const params = { id, visibility };
     return viewerStore.request(
-      model_edges_schemas.visibility,
-      { id, visibility },
+      { schema, params },
       {
         response_function: () => modelEdgesCommonStyle.mutateModelEdgesStyle(id, { visibility }),
       },

package/internal/stores/data_style/model/points/size.js

@@ -6,7 +6,7 @@ import { useModelPointsCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const model_points_schemas = viewer_schemas.opengeodeweb_viewer.model.points;
+const schema = viewer_schemas.opengeodeweb_viewer.model.points.size;
 
 export function useModelPointsSizeStyle() {
   const viewerStore = useViewerStore();
@@ -17,9 +17,12 @@ export function useModelPointsSizeStyle() {
   }
 
   function setModelPointsSize(id, size) {
+    const params = { id, size };
     return viewerStore.request(
-      model_points_schemas.size,
-      { id, size },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () => modelPointsCommonStyle.mutateModelPointsStyle(id, { size }),
       },

package/internal/stores/data_style/model/points/visibility.js

@@ -6,7 +6,7 @@ import { useModelPointsCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const model_points_schemas = viewer_schemas.opengeodeweb_viewer.model.points;
+const schema = viewer_schemas.opengeodeweb_viewer.model.points.visibility;
 
 export function useModelPointsVisibilityStyle() {
   const viewerStore = useViewerStore();
@@ -17,9 +17,9 @@ export function useModelPointsVisibilityStyle() {
   }
 
   function setModelPointsVisibility(id, visibility) {
+    const params = { id, visibility };
     return viewerStore.request(
-      model_points_schemas.visibility,
-      { id, visibility },
+      { schema, params },
       {
         response_function: () =>
           modelPointsCommonStyle.mutateModelPointsStyle(id, {

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

@@ -128,9 +128,10 @@ function useModelVisibilityStyle(componentStyleFunctions) {
   }
 
   function setModelVisibility(modelId, visibility) {
+    const schema = model_schemas.visibility;
+    const params = { id: modelId, visibility };
     return viewerStore.request(
-      model_schemas.visibility,
-      { id: modelId, visibility },
+      { schema, params },
       {
         response_function: async () => {
           await hybridViewerStore.setVisibility(modelId, visibility);

package/internal/stores/hybrid_viewer.js

@@ -1,19 +1,9 @@
+import { BACKGROUND_GREY_VALUE, RGB_MAX } from "./hybrid_viewer_constants";
 import { centerCameraOnPosition } from "./hybrid_viewer_camera";
 
-const RGB_MAX = 255;
-const BACKGROUND_GREY_VALUE = 180;
-const ACTOR_DARK_VALUE = 20;
-
-const bgVal = BACKGROUND_GREY_VALUE / RGB_MAX;
-const BACKGROUND_COLOR = [bgVal, bgVal, bgVal];
-const actVal = ACTOR_DARK_VALUE / RGB_MAX;
-const ACTOR_COLOR = [actVal, actVal, actVal];
-const HOVER_THROTTLE_MS = 50,
-  HOVER_TIMEOUT_MS = 500,
-  WHEEL_TIME_OUT_MS = 600;
-const RGBA_CHANNELS = 4,
-  SAMPLE_SIZE = 10,
-  TOTAL_CHANNELS = 400;
+const RGBA_CHANNELS = 4;
+const SAMPLE_SIZE = 10;
+const TOTAL_CHANNELS = 400;
 
 function mapRect(rect, latestImage, canvasRect) {
   const scaleX = latestImage.width / canvasRect.width;
@@ -73,11 +63,15 @@ function computeAverageBrightness(rect, options) {
 function performClickPicking(event, options) {
   const { container, viewerStore, viewer_schemas, genericRenderWindow, syncRemoteCamera } = options;
   const rect = container.getBoundingClientRect();
+  const schema = viewer_schemas.opengeodeweb_viewer.viewer.get_point_position;
+  const params = {
+    x: Math.round(event.clientX - rect.left),
+    y: Math.round(rect.height - (event.clientY - rect.top)),
+  };
   viewerStore.request(
-    viewer_schemas.opengeodeweb_viewer.viewer.get_point_position,
     {
-      x: Math.round(event.clientX - rect.left),
-      y: Math.round(rect.height - (event.clientY - rect.top)),
+      schema,
+      params,
     },
     {
       response_function: ({ x, y, z }) => {
@@ -111,13 +105,17 @@ function performHoverHighlight(event, options) {
     return;
   }
   const rect = container.getBoundingClientRect();
+  const schema = viewer_schemas.opengeodeweb_viewer.viewer.get_point_position;
+  const params = {
+    x: Math.round(event.clientX - rect.left),
+    y: Math.round(rect.height - (event.clientY - rect.top)),
+    field_type: hover_highlight_field_type.value,
+    ids: Object.keys(hybridDb),
+  };
   viewerStore.request(
-    viewer_schemas.opengeodeweb_viewer.viewer.highlight,
     {
-      x: Math.round(event.clientX - rect.left),
-      y: Math.round(rect.height - (event.clientY - rect.top)),
-      field_type: hover_highlight_field_type.value,
-      ids: Object.keys(hybridDb),
+      schema,
+      params,
     },
     {
       response_function: onResponse,
@@ -127,12 +125,14 @@ function performHoverHighlight(event, options) {
 
 function performClearHoverHighlight(options) {
   const { viewerStore, viewer_schemas, hover_highlight_field_type, hybridDb } = options;
-  viewerStore.request(viewer_schemas.opengeodeweb_viewer.viewer.highlight, {
+  const schema = viewer_schemas.opengeodeweb_viewer.viewer.clear_highlight;
+  const params = {
     x: -1,
     y: -1,
     field_type: hover_highlight_field_type.value,
     ids: Object.keys(hybridDb),
-  });
+  };
+  viewerStore.request({ schema, params });
 }
 
 async function performAddItem(id, options) {
@@ -179,10 +179,9 @@ async function performSetZScaling(z_scale, options) {
   }
   renderer.resetCamera();
   genericRenderWindow.getRenderWindow().render();
-  const schema = viewer_schemas?.opengeodeweb_viewer?.viewer?.set_z_scaling;
-  if (schema) {
-    await viewerStore.request(schema, { z_scale });
-  }
+  const schema = viewer_schemas.opengeodeweb_viewer.viewer.set_z_scaling;
+  const params = { z_scale };
+  await viewerStore.request({ schema, params });
   remoteRender();
 }
 
@@ -308,11 +307,6 @@ function performClear(options) {
 }
 
 export {
-  BACKGROUND_COLOR,
-  ACTOR_COLOR,
-  WHEEL_TIME_OUT_MS,
-  HOVER_THROTTLE_MS,
-  HOVER_TIMEOUT_MS,
   computeAverageBrightness,
   performAddItem,
   performClearHoverHighlight,

package/internal/stores/hybrid_viewer_camera.js

@@ -140,10 +140,9 @@ async function performFocusCameraOnObject(id, options) {
 
   let bounds = [];
   if (block_ids.length > 0) {
-    bounds = await viewerStore.request(viewer_schemas.opengeodeweb_viewer.model.get_blocks_bounds, {
-      id,
-      block_ids,
-    });
+    const schema = viewer_schemas.opengeodeweb_viewer.model.get_blocks_bounds;
+    const params = { id, block_ids };
+    bounds = await viewerStore.request({ schema, params });
   } else {
     bounds = hybridDb[id].actor.getBounds();
   }
@@ -168,9 +167,13 @@ function performSyncRemoteCamera(options) {
     options;
   const camera = genericRenderWindow.getRenderer().getActiveCamera();
   const options_camera = getCameraOptions(camera);
+  const schema = viewer_schemas.opengeodeweb_viewer.viewer.update_camera;
+  const params = { camera_options: options_camera };
   viewerStore.request(
-    viewer_schemas.opengeodeweb_viewer.viewer.update_camera,
-    { camera_options: options_camera },
+    {
+      schema,
+      params,
+    },
     {
       response_function: () => {
         remoteRender();

package/internal/stores/hybrid_viewer_constants.js

@@ -0,0 +1,21 @@
+const RGB_MAX = 255;
+const BACKGROUND_GREY_VALUE = 180;
+const ACTOR_DARK_VALUE = 20;
+
+const bgVal = BACKGROUND_GREY_VALUE / RGB_MAX;
+const BACKGROUND_COLOR = [bgVal, bgVal, bgVal];
+const actVal = ACTOR_DARK_VALUE / RGB_MAX;
+const ACTOR_COLOR = [actVal, actVal, actVal];
+const HOVER_THROTTLE_MS = 50;
+const HOVER_TIMEOUT_MS = 500;
+const WHEEL_TIME_OUT_MS = 600;
+
+export {
+  ACTOR_COLOR,
+  BACKGROUND_COLOR,
+  BACKGROUND_GREY_VALUE,
+  HOVER_THROTTLE_MS,
+  HOVER_TIMEOUT_MS,
+  RGB_MAX,
+  WHEEL_TIME_OUT_MS,
+};

package/internal/stores/hybrid_viewer_highlight.js

@@ -1,5 +1,6 @@
-import { HOVER_THROTTLE_MS, HOVER_TIMEOUT_MS, performHoverHighlight } from "./hybrid_viewer";
+import { HOVER_THROTTLE_MS, HOVER_TIMEOUT_MS } from "./hybrid_viewer_constants";
 import { database } from "@ogw_internal/database/database.js";
+import { performHoverHighlight } from "./hybrid_viewer";
 
 function createClearHoverData(hoverTimeoutRef, hoverData, currentHoverId) {
   return function clearHoverData() {

package/internal/utils/api_fetch.js

@@ -6,7 +6,7 @@ const ERROR_400 = 400;
 
 export function api_fetch(
   microservice,
-  { schema, params },
+  { schema, params, headers },
   { request_error_function, response_function, response_error_function, timeout } = {},
 ) {
   const feedbackStore = useFeedbackStore();
@@ -28,6 +28,7 @@ export function api_fetch(
   const method = schema.methods.find((methodItem) => methodItem !== "OPTIONS");
   const request_options = {
     method,
+    headers,
   };
   if (!_.isEmpty(body)) {
     request_options.body = body;

package/internal/utils/viewer_call.js

@@ -6,8 +6,8 @@ const ERROR_400 = 400;
 
 export function viewer_call(
   microservice,
-  { schema, params = {} },
-  { request_error_function, response_function, response_error_function, timeout } = {},
+  { schema, params = {}, timeout },
+  { request_error_function, response_function, response_error_function } = {},
 ) {
   const feedbackStore = useFeedbackStore();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.22.1-rc.1",
+  "version": "10.22.1",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {
@@ -34,8 +34,8 @@
     "build": ""
   },
   "dependencies": {
-    "@geode/opengeodeweb-back": "next",
-    "@geode/opengeodeweb-viewer": "next",
+    "@geode/opengeodeweb-back": "latest",
+    "@geode/opengeodeweb-viewer": "latest",
     "@google-cloud/run": "3.2.0",
     "@kitware/vtk.js": "33.3.0",
     "@mdi/font": "7.4.47",

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

@@ -40,9 +40,10 @@ describe("mesh cells", () => {
       const result = dataStyleStore.setMeshCellsVisibility(id, visibility);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_cells_schemas.visibility;
+      const params = { id, visibility };
       expect(spy).toHaveBeenCalledWith(
-        mesh_cells_schemas.visibility,
-        { id, visibility },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -61,9 +62,10 @@ describe("mesh cells", () => {
       const result = dataStyleStore.setMeshCellsColor(id, color);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_cells_schemas.color;
+      const params = { id, color };
       expect(spy).toHaveBeenCalledWith(
-        mesh_cells_schemas.color,
-        { id, color },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -81,9 +83,10 @@ describe("mesh cells", () => {
       const result = dataStyleStore.setMeshCellsVertexAttributeName(id, vertex_attribute.name);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_cells_schemas.attribute.vertex.name;
+      const params = { id, ...vertex_attribute };
       expect(spy).toHaveBeenCalledWith(
-        mesh_cells_schemas.attribute.vertex.name,
-        { id, ...vertex_attribute },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -101,9 +104,10 @@ describe("mesh cells", () => {
       const result = dataStyleStore.setMeshCellsCellAttributeName(id, cell_attribute.name);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_cells_schemas.attribute.cell.name;
+      const params = { id, ...cell_attribute };
       expect(spy).toHaveBeenCalledWith(
-        mesh_cells_schemas.attribute.cell.name,
-        { id, ...cell_attribute },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },

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

@@ -38,9 +38,10 @@ describe("mesh edges", () => {
       const result = dataStyleStore.setMeshEdgesVisibility(id, visibility);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_edges_schemas.visibility;
+      const params = { id, visibility };
       expect(spy).toHaveBeenCalledWith(
-        mesh_edges_schemas.visibility,
-        { id, visibility },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -57,9 +58,10 @@ describe("mesh edges", () => {
       const result = dataStyleStore.setMeshEdgesColor(id, color);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_edges_schemas.color;
+      const params = { id, color };
       expect(spy).toHaveBeenCalledWith(
-        mesh_edges_schemas.color,
-        { id, color },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -74,9 +76,10 @@ describe("mesh edges", () => {
 
       const spy = vi.spyOn(viewerStore, "request");
       await dataStyleStore.setMeshEdgesVertexAttributeName(id, vertex_attribute.name);
+      const schema = mesh_edges_schemas.attribute.vertex.name;
+      const params = { id, ...vertex_attribute };
       expect(spy).toHaveBeenCalledWith(
-        mesh_edges_schemas.attribute.vertex.name,
-        { id, ...vertex_attribute },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -91,9 +94,10 @@ describe("mesh edges", () => {
 
       const spy = vi.spyOn(viewerStore, "request");
       await dataStyleStore.setMeshEdgesEdgeAttributeName(id, edge_attribute.name);
+      const schema = mesh_edges_schemas.attribute.edge.name;
+      const params = { id, ...edge_attribute };
       expect(spy).toHaveBeenCalledWith(
-        mesh_edges_schemas.attribute.edge.name,
-        { id, ...edge_attribute },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },

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

@@ -36,9 +36,10 @@ describe("mesh", () => {
       const result = dataStyleStore.setMeshVisibility(id, visibility);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_schemas.visibility;
+      const params = { id, visibility };
       expect(spy).toHaveBeenCalledWith(
-        mesh_schemas.visibility,
-        { id, visibility },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },