@geode/opengeodeweb-front 10.25.0-rc.7 → 10.25.0

package/internal/stores/data_style/model/blocks/polyhedron.js

@@ -16,24 +16,24 @@ export function useModelBlocksPolyhedronAttribute() {
   const viewerStore = useViewerStore();
 
   function modelBlocksPolyhedronAttribute(modelId, blockId) {
-    return modelBlocksCommonStyle.modelBlockStyle(modelId, blockId).polyhedron_attribute;
+    return modelBlocksCommonStyle.modelBlockColoring(modelId, blockId).polyhedron;
   }
 
   function modelBlocksPolyhedronAttributeStoredConfig(modelId, blockId, name) {
     const { storedConfigs } = modelBlocksPolyhedronAttribute(modelId, blockId);
-    if (name && storedConfigs && name in storedConfigs) {
+    if (name in storedConfigs) {
       return storedConfigs[name];
     }
-    return {
+    return setModelBlocksPolyhedronAttributeStoredConfig(modelId, [blockId], name, {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    };
+    });
   }
 
   function mutateModelBlocksPolyhedronStyle(modelId, blockIds, values) {
-    return modelBlocksCommonStyle.mutateModelBlocksStyle(modelId, blockIds, {
-      polyhedron_attribute: values,
+    return modelBlocksCommonStyle.mutateModelBlocksColoring(modelId, blockIds, {
+      polyhedron: values,
     });
   }
 
@@ -51,24 +51,11 @@ export function useModelBlocksPolyhedronAttribute() {
 
   async function setModelBlocksPolyhedronAttributeName(modelId, blockIds, name) {
     const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, blockIds);
-
-    const updates = { name };
-    const polyhedron = modelBlocksPolyhedronAttribute(modelId, blockIds[0]);
-    if (!(name in polyhedron.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: () => mutateModelBlocksPolyhedronStyle(modelId, blockIds, updates),
+        response_function: () => mutateModelBlocksPolyhedronStyle(modelId, blockIds, { name }),
       },
     );
   }

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

@@ -16,24 +16,24 @@ export function useModelBlocksVertexAttribute() {
   const viewerStore = useViewerStore();
 
   function modelBlocksVertexAttribute(modelId, blockId) {
-    return modelBlocksCommonStyle.modelBlockStyle(modelId, blockId).vertex_attribute;
+    return modelBlocksCommonStyle.modelBlockColoring(modelId, blockId).vertex;
   }
 
   function modelBlocksVertexAttributeStoredConfig(modelId, blockId, name) {
     const { storedConfigs } = modelBlocksVertexAttribute(modelId, blockId);
-    if (name && storedConfigs && name in storedConfigs) {
+    if (name in storedConfigs) {
       return storedConfigs[name];
     }
-    return {
+    return setModelBlocksVertexAttributeStoredConfig(modelId, [blockId], name, {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    };
+    });
   }
 
   function mutateModelBlocksVertexStyle(modelId, blockIds, values) {
-    return modelBlocksCommonStyle.mutateModelBlocksStyle(modelId, blockIds, {
-      vertex_attribute: values,
+    return modelBlocksCommonStyle.mutateModelBlocksColoring(modelId, blockIds, {
+      vertex: values,
     });
   }
 
@@ -51,24 +51,11 @@ export function useModelBlocksVertexAttribute() {
 
   async function setModelBlocksVertexAttributeName(modelId, blockIds, name) {
     const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, blockIds);
-
-    const updates = { name };
-    const vertex = modelBlocksVertexAttribute(modelId, blockIds[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: () => mutateModelBlocksVertexStyle(modelId, blockIds, updates),
+        response_function: () => mutateModelBlocksVertexStyle(modelId, blockIds, { name }),
       },
     );
   }

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

@@ -1,4 +1,3 @@
-import { DEFAULT_MODEL_COMPONENT_TYPE_COLORS } from "@ogw_front/utils/default_styles";
 import { dispatchToComponentTypes } from "./visibility";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
@@ -79,7 +78,7 @@ function useModelColorStyle(componentStyleFunctions) {
   };
 
   function getModelComponentColor(modelId, componentId) {
-    return dataStyleState.getComponentStyle(modelId, componentId).color;
+    return dataStyleState.getComponentStyle(modelId, componentId).coloring.constant;
   }
 
   function getModelComponentEffectiveColor(modelId, componentId, type) {
@@ -90,27 +89,30 @@ function useModelColorStyle(componentStyleFunctions) {
     return modelComponentTypeColor(modelId, type);
   }
 
-  function getModelComponentColorMode(modelId, componentId) {
-    const mode = dataStyleState.getComponentStyle(modelId, componentId).color_mode || "constant";
-    return mode === "constant" ? "color" : mode;
+  function getModelComponentActiveColoring(modelId, componentId) {
+    return dataStyleState.getComponentStyle(modelId, componentId).coloring.active;
   }
 
   function modelComponentTypeColor(modelId, type) {
     return (
-      dataStyleState.getModelComponentTypeStyle(modelId, type).color ||
-      DEFAULT_MODEL_COMPONENT_TYPE_COLORS[type]
+      dataStyleState.getModelComponentTypeStyle(modelId, type).coloring.constant ||
+      dataStyleState.getStyle(modelId)[`${type.toLowerCase()}s`].coloring.constant
     );
   }
 
-  function getModelComponentTypeColorMode(modelId, type) {
-    const mode = dataStyleState.getModelComponentTypeStyle(modelId, type).color_mode || "constant";
-    return mode === "constant" ? "color" : mode;
+  function getModelComponentTypeActiveColoring(modelId, type) {
+    return (
+      dataStyleState.getModelComponentTypeStyle(modelId, type).coloring.active ||
+      dataStyleState.getStyle(modelId)[`${type.toLowerCase()}s`].coloring.active
+    );
   }
 
   async function setModelComponentTypeColor(modelId, type, color) {
     await modelCommonStyle.mutateModelComponentTypeStyle(modelId, type, {
-      color,
-      color_mode: "constant",
+      coloring: {
+        constant: color,
+        active: "constant",
+      },
     });
     const idsForType = await dataStore.getMeshComponentGeodeIds(modelId, type);
     if (idsForType.length === 0) {
@@ -119,22 +121,25 @@ function useModelColorStyle(componentStyleFunctions) {
     await setModelComponentsColor(modelId, idsForType, color);
   }
 
-  async function setModelComponentTypeColorMode(modelId, type, color_mode) {
-    const mode = color_mode === "color" ? "constant" : color_mode;
-    await modelCommonStyle.mutateModelComponentTypeStyle(modelId, type, { color_mode: mode });
+  async function setModelComponentTypeActiveColoring(modelId, type, activeColoring) {
+    await modelCommonStyle.mutateModelComponentTypeStyle(modelId, type, {
+      coloring: { active: activeColoring },
+    });
     const idsForType = await dataStore.getMeshComponentGeodeIds(modelId, type);
     if (idsForType.length === 0) {
       return;
     }
 
-    if (mode === "random" || mode === "constant") {
-      await setModelComponentsColor(modelId, idsForType, undefined, mode);
+    if (activeColoring === "random" || activeColoring === "constant") {
+      await setModelComponentsColor(modelId, idsForType, undefined, activeColoring);
       return;
     }
 
-    await modelCommonStyle.mutateComponentStyles(modelId, idsForType, { color_mode: mode });
+    await modelCommonStyle.mutateComponentStyles(modelId, idsForType, {
+      coloring: { active: activeColoring },
+    });
     const { getName, setName, getRange, setRange, getColorMap, setColorMap } =
-      ATTRIBUTE_FUNCTIONS[type][mode];
+      ATTRIBUTE_FUNCTIONS[type][activeColoring];
 
     const name = getName(modelId, idsForType[0]);
     if (name) {
@@ -150,17 +155,18 @@ function useModelColorStyle(componentStyleFunctions) {
     }
   }
 
-  async function setModelComponentColorMode(modelId, componentId, color_mode) {
-    const mode = color_mode === "color" ? "constant" : color_mode;
-    await modelCommonStyle.mutateComponentStyle(modelId, componentId, { color_mode: mode });
-    if (mode === "random" || mode === "constant") {
-      await setModelComponentsColor(modelId, [componentId], undefined, mode);
+  async function setModelComponentActiveColoring(modelId, componentId, activeColoring) {
+    await modelCommonStyle.mutateComponentStyle(modelId, componentId, {
+      coloring: { active: activeColoring },
+    });
+    if (activeColoring === "random" || activeColoring === "constant") {
+      await setModelComponentsColor(modelId, [componentId], undefined, activeColoring);
       return;
     }
 
     const type = await dataStore.meshComponentType(modelId, componentId);
     const { getName, setName, getRange, setRange, getColorMap, setColorMap } =
-      ATTRIBUTE_FUNCTIONS[type][mode];
+      ATTRIBUTE_FUNCTIONS[type][activeColoring];
 
     const name = getName(modelId, componentId);
     if (name) {
@@ -176,27 +182,47 @@ function useModelColorStyle(componentStyleFunctions) {
     }
   }
 
-  async function setModelComponentsColor(modelId, componentIds, color, color_mode = "constant") {
-    await modelCommonStyle.mutateComponentStyles(modelId, componentIds, { color, color_mode });
+  async function setModelComponentsColor(
+    modelId,
+    componentIds,
+    color,
+    activeColoring = "constant",
+  ) {
+    await modelCommonStyle.mutateComponentStyles(modelId, componentIds, {
+      coloring: {
+        constant: color,
+        active: activeColoring,
+      },
+    });
     return await dispatchToComponentTypes(
       modelId,
       componentIds,
       "Color",
       { componentStyleFunctions },
       color,
-      color_mode,
+      activeColoring,
     );
   }
 
+  function getModelColor(modelId) {
+    return dataStyleState.getStyle(modelId).coloring.constant;
+  }
+
+  function getModelActiveColoring(modelId) {
+    return dataStyleState.getStyle(modelId).coloring.active;
+  }
+
   return {
+    getModelColor,
+    getModelActiveColoring,
     getModelComponentColor,
     getModelComponentEffectiveColor,
-    getModelComponentColorMode,
+    getModelComponentActiveColoring,
     modelComponentTypeColor,
-    getModelComponentTypeColorMode,
+    getModelComponentTypeActiveColoring,
     setModelComponentTypeColor,
-    setModelComponentTypeColorMode,
-    setModelComponentColorMode,
+    setModelComponentTypeActiveColoring,
+    setModelComponentActiveColoring,
     setModelComponentsColor,
   };
 }

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

@@ -59,7 +59,7 @@ export function useModelCommonStyle() {
     });
   }
 
-  async function setModelTypeColor(id, component_ids, color, schema, color_mode = "constant") {
+  async function setModelTypeColor(id, component_ids, color, schema, activeColoring = "constant") {
     if (!component_ids?.length) {
       return;
     }
@@ -69,12 +69,13 @@ export function useModelCommonStyle() {
       return;
     }
 
-    if (color_mode === "constant" && color !== undefined) {
-      await mutateComponentStyles(id, component_ids, { color });
-    }
-
-    const params = { id, block_ids: viewer_ids, color_mode };
-    if (color_mode === "constant" && color !== undefined) {
+    const params = { id, block_ids: viewer_ids, color_mode: activeColoring };
+    if (activeColoring === "constant") {
+      await mutateComponentStyles(id, component_ids, {
+        coloring: {
+          constant: color,
+        },
+      });
       params.color = color;
     }
 
@@ -82,8 +83,12 @@ export function useModelCommonStyle() {
       { schema, params },
       {
         response_function: async (colors) => {
-          if (color_mode === "constant" && color !== undefined) {
-            await mutateComponentStyles(id, component_ids, { color });
+          if (activeColoring === "constant") {
+            await mutateComponentStyles(id, component_ids, {
+              coloring: {
+                constant: color,
+              },
+            });
             return;
           }
 
@@ -95,7 +100,11 @@ export function useModelCommonStyle() {
             id,
             colors.map(({ geode_id, color: color_value }) => ({
               id_component: geode_id,
-              values: { color: color_value },
+              values: {
+                coloring: {
+                  constant: color_value,
+                },
+              },
             })),
           );
         },

package/internal/stores/data_style/model/corners/color.js

@@ -1,5 +1,6 @@
 import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
 import { useModelCornersCommonStyle } from "./common";
+import { useModelCornersVertexAttribute } from "./vertex";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 const schema = viewer_schemas.opengeodeweb_viewer.model.corners.color;
@@ -7,19 +8,70 @@ const schema = viewer_schemas.opengeodeweb_viewer.model.corners.color;
 export function useModelCornersColor() {
   const modelCommonStyle = useModelCommonStyle();
   const modelCornersCommonStyle = useModelCornersCommonStyle();
+  const modelCornersVertexAttribute = useModelCornersVertexAttribute();
+
+  function modelCornerColoring(id, corner_id) {
+    return modelCornersCommonStyle.modelCornerStyle(id, corner_id).coloring;
+  }
 
   function modelCornerColor(id, corner_id) {
-    return modelCornersCommonStyle.modelCornerStyle(id, corner_id).color;
+    return modelCornerColoring(id, corner_id).constant;
   }
 
-  function setModelCornersColor(modelId, corners_ids, color, color_mode = "constant") {
-    return modelCommonStyle.setModelTypeColor(modelId, corners_ids, color, schema, color_mode);
+  function setModelCornersColor(modelId, corners_ids, color, activeColoring = "constant") {
+    return modelCommonStyle.setModelTypeColor(modelId, corners_ids, color, schema, activeColoring);
   }
 
-  function modelCornerColorMode(id, corner_id) {
-    const mode = modelCornersCommonStyle.modelCornerStyle(id, corner_id).color_mode || "constant";
-    return mode === "constant" ? "color" : mode;
+  function modelCornerActiveColoring(id, corner_id) {
+    return modelCornerColoring(id, corner_id).active;
+  }
+
+  async function setModelCornersActiveColoring(modelId, corners_ids, activeColoring) {
+    await modelCommonStyle.mutateComponentStyles(modelId, corners_ids, {
+      coloring: { active: activeColoring },
+    });
+    if (activeColoring === "constant" || activeColoring === "random") {
+      const color = modelCornerColor(modelId, corners_ids[0]);
+      return setModelCornersColor(modelId, corners_ids, color, activeColoring);
+    }
+
+    if (activeColoring === "vertex") {
+      const name = modelCornersVertexAttribute.modelCornersVertexAttributeName(
+        modelId,
+        corners_ids[0],
+      );
+      await modelCornersVertexAttribute.setModelCornersVertexAttributeName(
+        modelId,
+        corners_ids,
+        name,
+      );
+      const [min, max] = modelCornersVertexAttribute.modelCornersVertexAttributeRange(
+        modelId,
+        corners_ids[0],
+      );
+      await modelCornersVertexAttribute.setModelCornersVertexAttributeRange(
+        modelId,
+        corners_ids,
+        min,
+        max,
+      );
+      const colorMap = modelCornersVertexAttribute.modelCornersVertexAttributeColorMap(
+        modelId,
+        corners_ids[0],
+      );
+      await modelCornersVertexAttribute.setModelCornersVertexAttributeColorMap(
+        modelId,
+        corners_ids,
+        colorMap,
+      );
+    }
   }
 
-  return { setModelCornersColor, modelCornerColor, modelCornerColorMode };
+  return {
+    setModelCornersColor,
+    modelCornerColoring,
+    modelCornerColor,
+    modelCornerActiveColoring,
+    setModelCornersActiveColoring,
+  };
 }

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

@@ -16,18 +16,27 @@ export function useModelCornersCommonStyle() {
     return merge({}, groupStyle, individualStyle);
   }
 
-  function mutateModelCornersStyle(id, corners_ids, values) {
-    return modelCommonStyle.mutateComponentStyles(id, corners_ids, values);
+  function modelCornerColoring(id, corner_id) {
+    return modelCornerStyle(id, corner_id).coloring;
   }
 
-  function mutateModelCornerStyle(id, corner_id, values) {
-    return modelCommonStyle.mutateComponentStyle(id, corner_id, values);
+  function mutateModelCornersColoring(id, corners_ids, values) {
+    return modelCommonStyle.mutateComponentStyles(id, corners_ids, {
+      coloring: values,
+    });
+  }
+
+  function mutateModelCornerColoring(id, corner_id, values) {
+    return modelCommonStyle.mutateComponentStyle(id, corner_id, {
+      coloring: values,
+    });
   }
 
   return {
     modelCornersStyle,
     modelCornerStyle,
-    mutateModelCornersStyle,
-    mutateModelCornerStyle,
+    modelCornerColoring,
+    mutateModelCornersColoring,
+    mutateModelCornerColoring,
   };
 }

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

@@ -34,34 +34,36 @@ export function useModelCornersStyle() {
       }
       visibilityGroups[visibility].push(corner_id);
 
-      const color_mode = style.color_mode || "constant";
-      if (color_mode === "constant" || color_mode === "random") {
-        const color_key = color_mode === "random" ? "random" : JSON.stringify(style.color);
+      const coloring = modelColorStyle.modelCornerColoring(modelId, corner_id);
+      const activeColoring = modelColorStyle.modelCornerActiveColoring(modelId, corner_id);
+      if (activeColoring === "constant") {
+        const color = modelColorStyle.modelCornerColor(modelId, corner_id);
+        const color_key = JSON.stringify(color);
         if (!colorGroups[color_key]) {
-          colorGroups[color_key] = { color_mode, color: style.color, corners_ids: [] };
+          colorGroups[color_key] = { activeColoring, color, corners_ids: [] };
         }
         colorGroups[color_key].corners_ids.push(corner_id);
+      } else if (activeColoring === "random") {
+        if (!colorGroups["random"]) {
+          colorGroups["random"] = { activeColoring, color: undefined, corners_ids: [] };
+        }
+        colorGroups["random"].corners_ids.push(corner_id);
       } else {
-        const attributeTypeKey = `${color_mode}_attribute`;
-        const attributeStyle = style[attributeTypeKey] || {};
+        const attributeStyle = coloring[activeColoring];
         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,
-              corners_ids: [],
-            };
-          }
-          attributeGroups[attributeGroupKey].corners_ids.push(corner_id);
+        const { minimum, maximum, colorMap } = attributeStyle.storedConfigs[name];
+        const attributeGroupKey = `${activeColoring}_${name}_${colorMap}_${minimum}_${maximum}`;
+        if (!attributeGroups[attributeGroupKey]) {
+          attributeGroups[attributeGroupKey] = {
+            activeColoring,
+            name,
+            minimum,
+            maximum,
+            colorMap,
+            corners_ids: [],
+          };
         }
+        attributeGroups[attributeGroupKey].corners_ids.push(corner_id);
       }
     }
 
@@ -69,8 +71,8 @@ export function useModelCornersStyle() {
       ...Object.entries(visibilityGroups).map(([visibility, ids]) =>
         modelVisibilityStyle.setModelCornersVisibility(modelId, ids, visibility === "true"),
       ),
-      ...Object.values(colorGroups).map(({ color_mode, color, corners_ids: ids }) =>
-        modelColorStyle.setModelCornersColor(modelId, ids, color, color_mode),
+      ...Object.values(colorGroups).map(({ activeColoring, color, corners_ids: ids }) =>
+        modelColorStyle.setModelCornersColor(modelId, ids, color, activeColoring),
       ),
       ...Object.values(attributeGroups).flatMap(
         ({ name, minimum, maximum, colorMap, corners_ids: ids }) => {

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

@@ -16,24 +16,24 @@ export function useModelCornersVertexAttribute() {
   const viewerStore = useViewerStore();
 
   function modelCornersVertexAttribute(modelId, cornerId) {
-    return modelCornersCommonStyle.modelCornerStyle(modelId, cornerId).vertex_attribute;
+    return modelCornersCommonStyle.modelCornerColoring(modelId, cornerId).vertex;
   }
 
   function modelCornersVertexAttributeStoredConfig(modelId, cornerId, name) {
     const { storedConfigs } = modelCornersVertexAttribute(modelId, cornerId);
-    if (name && storedConfigs && name in storedConfigs) {
+    if (name in storedConfigs) {
       return storedConfigs[name];
     }
-    return {
+    return setModelCornersVertexAttributeStoredConfig(modelId, [cornerId], name, {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    };
+    });
   }
 
   function mutateModelCornersVertexStyle(modelId, cornerIds, values) {
-    return modelCornersCommonStyle.mutateModelCornersStyle(modelId, cornerIds, {
-      vertex_attribute: values,
+    return modelCornersCommonStyle.mutateModelCornersColoring(modelId, cornerIds, {
+      vertex: values,
     });
   }
 
@@ -51,24 +51,11 @@ export function useModelCornersVertexAttribute() {
 
   async function setModelCornersVertexAttributeName(modelId, cornerIds, name) {
     const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, cornerIds);
-
-    const updates = { name };
-    const vertex = modelCornersVertexAttribute(modelId, cornerIds[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: () => mutateModelCornersVertexStyle(modelId, cornerIds, updates),
+        response_function: () => mutateModelCornersVertexStyle(modelId, cornerIds, { name }),
       },
     );
   }