@geode/opengeodeweb-front 10.22.1 → 10.23.0-rc.2

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

@@ -1,6 +1,8 @@
 import { useDataStore } from "@ogw_front/stores/data";
 import { useModelSurfacesColor } from "./color";
 import { useModelSurfacesCommonStyle } from "./common";
+import { useModelSurfacesPolygonAttribute } from "./polygon";
+import { useModelSurfacesVertexAttribute } from "./vertex";
 import { useModelSurfacesVisibility } from "./visibility";
 
 async function setModelSurfacesDefaultStyle(_id) {
@@ -12,6 +14,8 @@ export function useModelSurfacesStyle() {
   const modelCommonStyle = useModelSurfacesCommonStyle();
   const modelVisibilityStyle = useModelSurfacesVisibility();
   const modelColorStyle = useModelSurfacesColor();
+  const modelSurfacesVertexAttribute = useModelSurfacesVertexAttribute();
+  const modelSurfacesPolygonAttribute = useModelSurfacesPolygonAttribute();
 
   async function applyModelSurfacesStyle(modelId) {
     const surfaces_ids = await dataStore.getSurfacesGeodeIds(modelId);
@@ -21,6 +25,7 @@ export function useModelSurfacesStyle() {
 
     const visibilityGroups = {};
     const colorGroups = {};
+    const attributeGroups = {};
 
     for (const surfaces_id of surfaces_ids) {
       const style = modelCommonStyle.modelSurfaceStyle(modelId, surfaces_id);
@@ -32,11 +37,34 @@ export function useModelSurfacesStyle() {
       visibilityGroups[visibility].push(surfaces_id);
 
       const color_mode = style.color_mode || "constant";
-      const color_key = color_mode === "random" ? "random" : JSON.stringify(style.color);
-      if (!colorGroups[color_key]) {
-        colorGroups[color_key] = { color_mode, color: style.color, surfaces_ids: [] };
+      if (color_mode === "constant" || color_mode === "random") {
+        const color_key = color_mode === "random" ? "random" : JSON.stringify(style.color);
+        if (!colorGroups[color_key]) {
+          colorGroups[color_key] = { color_mode, color: style.color, surfaces_ids: [] };
+        }
+        colorGroups[color_key].surfaces_ids.push(surfaces_id);
+      } else {
+        const attributeTypeKey = `${color_mode}_attribute`;
+        const attributeStyle = style[attributeTypeKey] || {};
+        const { name } = attributeStyle;
+        if (name) {
+          const storedConfig =
+            (attributeStyle.storedConfigs && attributeStyle.storedConfigs[name]) || {};
+          const { minimum, maximum, colorMap } = storedConfig;
+          const attributeGroupKey = `${color_mode}_${name}_${colorMap}_${minimum}_${maximum}`;
+          if (!attributeGroups[attributeGroupKey]) {
+            attributeGroups[attributeGroupKey] = {
+              color_mode,
+              name,
+              minimum,
+              maximum,
+              colorMap,
+              surfaces_ids: [],
+            };
+          }
+          attributeGroups[attributeGroupKey].surfaces_ids.push(surfaces_id);
+        }
       }
-      colorGroups[color_key].surfaces_ids.push(surfaces_id);
     }
 
     const promises = [
@@ -46,6 +74,32 @@ export function useModelSurfacesStyle() {
       ...Object.values(colorGroups).map(({ color_mode, color, surfaces_ids: ids }) =>
         modelColorStyle.setModelSurfacesColor(modelId, ids, color, color_mode),
       ),
+      ...Object.values(attributeGroups).flatMap(
+        ({ color_mode, name, minimum, maximum, colorMap, surfaces_ids: ids }) => {
+          const isVertex = color_mode === "vertex";
+          const attributeStyle = isVertex
+            ? modelSurfacesVertexAttribute
+            : modelSurfacesPolygonAttribute;
+          const setAttributeName = isVertex
+            ? attributeStyle.setModelSurfacesVertexAttributeName
+            : attributeStyle.setModelSurfacesPolygonAttributeName;
+          const setAttributeRange = isVertex
+            ? attributeStyle.setModelSurfacesVertexAttributeRange
+            : attributeStyle.setModelSurfacesPolygonAttributeRange;
+          const setAttributeColorMap = isVertex
+            ? attributeStyle.setModelSurfacesVertexAttributeColorMap
+            : attributeStyle.setModelSurfacesPolygonAttributeColorMap;
+
+          const list = [setAttributeName(modelId, ids, name)];
+          if (minimum !== undefined && maximum !== undefined) {
+            list.push(setAttributeRange(modelId, ids, minimum, maximum));
+          }
+          if (colorMap) {
+            list.push(setAttributeColorMap(modelId, ids, colorMap));
+          }
+          return list;
+        },
+      ),
     ];
 
     return Promise.all(promises);
@@ -57,5 +111,7 @@ export function useModelSurfacesStyle() {
     ...modelCommonStyle,
     ...modelVisibilityStyle,
     ...modelColorStyle,
+    ...modelSurfacesVertexAttribute,
+    ...modelSurfacesPolygonAttribute,
   };
 }

package/internal/stores/data_style/model/surfaces/polygon.js

@@ -0,0 +1,144 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
+
+// Local imports
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
+import { useDataStore } from "@ogw_front/stores/data";
+import { useModelSurfacesCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
+
+// Local constants
+const schema = viewer_schemas.opengeodeweb_viewer.model.surfaces.attribute.polygon;
+
+export function useModelSurfacesPolygonAttribute() {
+  const dataStore = useDataStore();
+  const modelSurfacesCommonStyle = useModelSurfacesCommonStyle();
+  const viewerStore = useViewerStore();
+
+  function modelSurfacesPolygonAttribute(modelId, surfaceId) {
+    return modelSurfacesCommonStyle.modelSurfaceStyle(modelId, surfaceId).polygon_attribute;
+  }
+
+  function modelSurfacesPolygonAttributeStoredConfig(modelId, surfaceId, name) {
+    const { storedConfigs } = modelSurfacesPolygonAttribute(modelId, surfaceId);
+    if (name && storedConfigs && name in storedConfigs) {
+      return storedConfigs[name];
+    }
+    return {
+      minimum: undefined,
+      maximum: undefined,
+      colorMap: undefined,
+    };
+  }
+
+  function mutateModelSurfacesPolygonStyle(modelId, surfaceIds, values) {
+    return modelSurfacesCommonStyle.mutateModelSurfacesStyle(modelId, surfaceIds, {
+      polygon_attribute: values,
+    });
+  }
+
+  function setModelSurfacesPolygonAttributeStoredConfig(modelId, surfaceIds, name, config) {
+    return mutateModelSurfacesPolygonStyle(modelId, surfaceIds, {
+      storedConfigs: {
+        [name]: config,
+      },
+    });
+  }
+
+  function modelSurfacesPolygonAttributeName(modelId, surfaceId) {
+    return modelSurfacesPolygonAttribute(modelId, surfaceId).name;
+  }
+
+  async function setModelSurfacesPolygonAttributeName(modelId, surfaceIds, name) {
+    const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, surfaceIds);
+
+    const updates = { name };
+    const polygon = modelSurfacesPolygonAttribute(modelId, surfaceIds[0]);
+    if (!(name in polygon.storedConfigs)) {
+      updates.storedConfigs = {
+        [name]: {
+          minimum: undefined,
+          maximum: undefined,
+          colorMap: undefined,
+        },
+      };
+    }
+
+    const params = { id: modelId, block_ids: viewer_ids, name };
+    return viewerStore.request(
+      { schema: schema.name, params },
+      {
+        response_function: () => mutateModelSurfacesPolygonStyle(modelId, surfaceIds, updates),
+      },
+    );
+  }
+
+  function modelSurfacesPolygonAttributeRange(modelId, surfaceId) {
+    const name = modelSurfacesPolygonAttributeName(modelId, surfaceId);
+    const storedConfig = modelSurfacesPolygonAttributeStoredConfig(modelId, surfaceId, name);
+    const { minimum, maximum } = storedConfig;
+    return [minimum, maximum];
+  }
+
+  async function setModelSurfacesPolygonAttributeRange(modelId, surfaceIds, minimum, maximum) {
+    const name = modelSurfacesPolygonAttributeName(modelId, surfaceIds[0]);
+    const colorMap = modelSurfacesPolygonAttributeColorMap(modelId, surfaceIds[0]);
+    const points = getRGBPointsFromPreset(colorMap);
+
+    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, surfaceIds);
+      const params = { id: modelId, block_ids: viewer_ids, points, minimum, maximum };
+      return viewerStore.request(
+        { schema: schema.color_map, params },
+        {
+          response_function: () =>
+            setModelSurfacesPolygonAttributeStoredConfig(modelId, surfaceIds, name, {
+              minimum,
+              maximum,
+            }),
+        },
+      );
+    }
+    return setModelSurfacesPolygonAttributeStoredConfig(modelId, surfaceIds, name, {
+      minimum,
+      maximum,
+    });
+  }
+
+  function modelSurfacesPolygonAttributeColorMap(modelId, surfaceId) {
+    const name = modelSurfacesPolygonAttributeName(modelId, surfaceId);
+    const storedConfig = modelSurfacesPolygonAttributeStoredConfig(modelId, surfaceId, name);
+    const { colorMap } = storedConfig;
+    return colorMap;
+  }
+
+  async function setModelSurfacesPolygonAttributeColorMap(modelId, surfaceIds, colorMap) {
+    const name = modelSurfacesPolygonAttributeName(modelId, surfaceIds[0]);
+    const storedConfig = modelSurfacesPolygonAttributeStoredConfig(modelId, surfaceIds[0], name);
+    const points = getRGBPointsFromPreset(colorMap);
+    const { minimum, maximum } = storedConfig;
+
+    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, surfaceIds);
+      const params = { id: modelId, block_ids: viewer_ids, points, minimum, maximum };
+      return viewerStore.request(
+        { schema: schema.color_map, params },
+        {
+          response_function: () =>
+            setModelSurfacesPolygonAttributeStoredConfig(modelId, surfaceIds, name, { colorMap }),
+        },
+      );
+    }
+    return setModelSurfacesPolygonAttributeStoredConfig(modelId, surfaceIds, name, { colorMap });
+  }
+
+  return {
+    modelSurfacesPolygonAttributeName,
+    modelSurfacesPolygonAttributeRange,
+    modelSurfacesPolygonAttributeColorMap,
+    modelSurfacesPolygonAttributeStoredConfig,
+    setModelSurfacesPolygonAttributeName,
+    setModelSurfacesPolygonAttributeRange,
+    setModelSurfacesPolygonAttributeColorMap,
+  };
+}

package/internal/stores/data_style/model/surfaces/vertex.js

@@ -0,0 +1,144 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
+
+// Local imports
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
+import { useDataStore } from "@ogw_front/stores/data";
+import { useModelSurfacesCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
+
+// Local constants
+const schema = viewer_schemas.opengeodeweb_viewer.model.surfaces.attribute.vertex;
+
+export function useModelSurfacesVertexAttribute() {
+  const dataStore = useDataStore();
+  const modelSurfacesCommonStyle = useModelSurfacesCommonStyle();
+  const viewerStore = useViewerStore();
+
+  function modelSurfacesVertexAttribute(modelId, surfaceId) {
+    return modelSurfacesCommonStyle.modelSurfaceStyle(modelId, surfaceId).vertex_attribute;
+  }
+
+  function modelSurfacesVertexAttributeStoredConfig(modelId, surfaceId, name) {
+    const { storedConfigs } = modelSurfacesVertexAttribute(modelId, surfaceId);
+    if (name && storedConfigs && name in storedConfigs) {
+      return storedConfigs[name];
+    }
+    return {
+      minimum: undefined,
+      maximum: undefined,
+      colorMap: undefined,
+    };
+  }
+
+  function mutateModelSurfacesVertexStyle(modelId, surfaceIds, values) {
+    return modelSurfacesCommonStyle.mutateModelSurfacesStyle(modelId, surfaceIds, {
+      vertex_attribute: values,
+    });
+  }
+
+  function setModelSurfacesVertexAttributeStoredConfig(modelId, surfaceIds, name, config) {
+    return mutateModelSurfacesVertexStyle(modelId, surfaceIds, {
+      storedConfigs: {
+        [name]: config,
+      },
+    });
+  }
+
+  function modelSurfacesVertexAttributeName(modelId, surfaceId) {
+    return modelSurfacesVertexAttribute(modelId, surfaceId).name;
+  }
+
+  async function setModelSurfacesVertexAttributeName(modelId, surfaceIds, name) {
+    const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, surfaceIds);
+
+    const updates = { name };
+    const vertex = modelSurfacesVertexAttribute(modelId, surfaceIds[0]);
+    if (!(name in vertex.storedConfigs)) {
+      updates.storedConfigs = {
+        [name]: {
+          minimum: undefined,
+          maximum: undefined,
+          colorMap: undefined,
+        },
+      };
+    }
+
+    const params = { id: modelId, block_ids: viewer_ids, name };
+    return viewerStore.request(
+      { schema: schema.name, params },
+      {
+        response_function: () => mutateModelSurfacesVertexStyle(modelId, surfaceIds, updates),
+      },
+    );
+  }
+
+  function modelSurfacesVertexAttributeRange(modelId, surfaceId) {
+    const name = modelSurfacesVertexAttributeName(modelId, surfaceId);
+    const storedConfig = modelSurfacesVertexAttributeStoredConfig(modelId, surfaceId, name);
+    const { minimum, maximum } = storedConfig;
+    return [minimum, maximum];
+  }
+
+  async function setModelSurfacesVertexAttributeRange(modelId, surfaceIds, minimum, maximum) {
+    const name = modelSurfacesVertexAttributeName(modelId, surfaceIds[0]);
+    const colorMap = modelSurfacesVertexAttributeColorMap(modelId, surfaceIds[0]);
+    const points = getRGBPointsFromPreset(colorMap);
+
+    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, surfaceIds);
+      const params = { id: modelId, block_ids: viewer_ids, points, minimum, maximum };
+      return viewerStore.request(
+        { schema: schema.color_map, params },
+        {
+          response_function: () =>
+            setModelSurfacesVertexAttributeStoredConfig(modelId, surfaceIds, name, {
+              minimum,
+              maximum,
+            }),
+        },
+      );
+    }
+    return setModelSurfacesVertexAttributeStoredConfig(modelId, surfaceIds, name, {
+      minimum,
+      maximum,
+    });
+  }
+
+  function modelSurfacesVertexAttributeColorMap(modelId, surfaceId) {
+    const name = modelSurfacesVertexAttributeName(modelId, surfaceId);
+    const storedConfig = modelSurfacesVertexAttributeStoredConfig(modelId, surfaceId, name);
+    const { colorMap } = storedConfig;
+    return colorMap;
+  }
+
+  async function setModelSurfacesVertexAttributeColorMap(modelId, surfaceIds, colorMap) {
+    const name = modelSurfacesVertexAttributeName(modelId, surfaceIds[0]);
+    const storedConfig = modelSurfacesVertexAttributeStoredConfig(modelId, surfaceIds[0], name);
+    const points = getRGBPointsFromPreset(colorMap);
+    const { minimum, maximum } = storedConfig;
+
+    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, surfaceIds);
+      const params = { id: modelId, block_ids: viewer_ids, points, minimum, maximum };
+      return viewerStore.request(
+        { schema: schema.color_map, params },
+        {
+          response_function: () =>
+            setModelSurfacesVertexAttributeStoredConfig(modelId, surfaceIds, name, { colorMap }),
+        },
+      );
+    }
+    return setModelSurfacesVertexAttributeStoredConfig(modelId, surfaceIds, name, { colorMap });
+  }
+
+  return {
+    modelSurfacesVertexAttributeName,
+    modelSurfacesVertexAttributeRange,
+    modelSurfacesVertexAttributeColorMap,
+    modelSurfacesVertexAttributeStoredConfig,
+    setModelSurfacesVertexAttributeName,
+    setModelSurfacesVertexAttributeRange,
+    setModelSurfacesVertexAttributeColorMap,
+  };
+}

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

@@ -1,8 +1,9 @@
-import { MESH_TYPES } from "@ogw_front/utils/default_styles";
+import { MESH_COMPONENT_TYPES } from "@ogw_front/utils/default_styles";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
+import { useModelSelection } from "./selection";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
@@ -11,7 +12,7 @@ const model_schemas = viewer_schemas.opengeodeweb_viewer.model;
 async function getModelComponentsMap(modelId) {
   const dataStore = useDataStore();
   const results = await Promise.all(
-    MESH_TYPES.map(async (type) => {
+    MESH_COMPONENT_TYPES.map(async (type) => {
       const geodeIds = await dataStore.getMeshComponentGeodeIds(modelId, type);
       return geodeIds.map((geode_id) => ({ geode_id, type }));
     }),
@@ -143,8 +144,8 @@ function useModelVisibilityStyle(componentStyleFunctions) {
   }
 
   async function setModelComponentsVisibility(modelId, componentIds, visibility) {
-    const typeIds = componentIds.filter((id) => MESH_TYPES.includes(id));
-    const individualIds = componentIds.filter((id) => !MESH_TYPES.includes(id));
+    const typeIds = componentIds.filter((id) => MESH_COMPONENT_TYPES.includes(id));
+    const individualIds = componentIds.filter((id) => !MESH_COMPONENT_TYPES.includes(id));
 
     const promises = [];
     for (const typeId of typeIds) {
@@ -176,11 +177,23 @@ function useModelVisibilityStyle(componentStyleFunctions) {
     await setModelComponentsVisibility(modelId, idsForType, visibility);
   }
 
+  function modelComponentVisibility(modelId, componentId) {
+    const selection = useModelSelection(modelId, dataStyleState);
+    return selection.value.includes(componentId);
+  }
+
+  function modelComponentTypeVisibility(modelId, componentType) {
+    const selection = useModelSelection(modelId, dataStyleState);
+    return selection.value.includes(componentType);
+  }
+
   return {
     modelVisibility,
     setModelVisibility,
     setModelComponentsVisibility,
     setModelComponentTypeVisibility,
+    modelComponentVisibility,
+    modelComponentTypeVisibility,
   };
 }
 

package/internal/stores/data_style/state.js

@@ -3,7 +3,13 @@ import { liveQuery } from "dexie";
 import merge from "lodash/merge";
 import { useObservable } from "@vueuse/rxjs";
 
-export function useDataStyleState() {
+let sharedState = undefined;
+
+function getSharedState() {
+  if (sharedState) {
+    return sharedState;
+  }
+
   const data_style_db = database.data_style;
   const model_component_datastyle_db = database.model_component_datastyle;
   const model_component_type_datastyle_db = database.model_component_type_datastyle;
@@ -20,23 +26,6 @@ export function useDataStyleState() {
     { initialValue: {} },
   );
 
-  const objectVisibility = computed(() => (id) => {
-    if (styles.value[id]) {
-      return styles.value[id].visibility;
-    }
-    return false;
-  });
-
-  const selectedObjects = computed(() => {
-    const selection = [];
-    for (const [id, value] of Object.entries(styles.value)) {
-      if (value.visibility === true) {
-        selection.push(id);
-      }
-    }
-    return selection;
-  });
-
   const modelComponentTypeStyles = useObservable(
     liveQuery(async () => {
       const all = await model_component_type_datastyle_db.toArray();
@@ -63,11 +52,104 @@ export function useDataStyleState() {
     { initialValue: {} },
   );
 
+  function updateComponentStyleCache(id_model, id_component, values) {
+    const key = `${id_model}_${id_component}`;
+    const current = componentStyles.value[key];
+    if (current) {
+      merge(current, values);
+    } else {
+      componentStyles.value[key] = merge({ id_model, id_component }, values);
+    }
+  }
+
+  function bulkUpdateComponentStyleCache(id_model, updates) {
+    const newVal = { ...componentStyles.value };
+    for (const { id_component, values } of updates) {
+      const key = `${id_model}_${id_component}`;
+      const current = newVal[key];
+      if (current) {
+        newVal[key] = merge({}, current, values);
+      } else {
+        newVal[key] = merge({ id_model, id_component }, values);
+      }
+    }
+    componentStyles.value = newVal;
+  }
+
+  function bulkUpdateComponentStylesCache(id_model, id_components, values) {
+    const newVal = { ...componentStyles.value };
+    for (const id_component of id_components) {
+      const key = `${id_model}_${id_component}`;
+      const current = newVal[key];
+      if (current) {
+        newVal[key] = merge({}, current, values);
+      } else {
+        newVal[key] = merge({ id_model, id_component }, values);
+      }
+    }
+    componentStyles.value = newVal;
+  }
+
+  function updateModelComponentTypeStyleCache(id_model, type, values) {
+    const key = `${id_model}_${type}`;
+    if (!modelComponentTypeStyles.value[key]) {
+      modelComponentTypeStyles.value[key] = { id_model, type };
+    }
+    merge(modelComponentTypeStyles.value[key], values);
+  }
+
+  function updateStyleCache(id, values) {
+    if (!styles.value[id]) {
+      styles.value[id] = { id };
+    }
+    merge(styles.value[id], values);
+  }
+
+  sharedState = {
+    styles,
+    modelComponentTypeStyles,
+    componentStyles,
+    updateComponentStyleCache,
+    bulkUpdateComponentStyleCache,
+    bulkUpdateComponentStylesCache,
+    updateModelComponentTypeStyleCache,
+    updateStyleCache,
+  };
+
+  return sharedState;
+}
+
+export function useDataStyleState() {
+  const data_style_db = database.data_style;
+  const model_component_datastyle_db = database.model_component_datastyle;
+  const model_component_type_datastyle_db = database.model_component_type_datastyle;
+
+  const state = getSharedState();
+  const { styles, modelComponentTypeStyles, componentStyles } = state;
+
+  const objectVisibility = computed(() => (id) => {
+    if (styles.value[id]) {
+      return styles.value[id].visibility;
+    }
+    return false;
+  });
+
+  const selectedObjects = computed(() => {
+    const selection = [];
+    for (const [id, value] of Object.entries(styles.value)) {
+      if (value.visibility === true) {
+        selection.push(id);
+      }
+    }
+    return selection;
+  });
+
   function getStyle(id) {
     return { ...toRaw(styles.value[id]) };
   }
 
   function mutateStyle(id, values) {
+    state.updateStyleCache(id, values);
     const style = getStyle(id);
     merge(style, values);
     return data_style_db.put(structuredClone({ id, ...toRaw(style) }));
@@ -92,13 +174,11 @@ export function useDataStyleState() {
   }
 
   return {
+    ...state,
     getStyle,
     getComponentStyle,
     getModelComponentTypeStyle,
     mutateStyle,
-    styles,
-    componentStyles,
-    modelComponentTypeStyles,
     objectVisibility,
     selectedObjects,
     clear,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.22.1",
+  "version": "10.23.0-rc.2",
   "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": "latest",
-    "@geode/opengeodeweb-viewer": "latest",
+    "@geode/opengeodeweb-back": "next",
+    "@geode/opengeodeweb-viewer": "next",
     "@google-cloud/run": "3.2.0",
     "@kitware/vtk.js": "33.3.0",
     "@mdi/font": "7.4.47",