@geode/opengeodeweb-front 10.28.1-rc.4 → 10.29.0-rc.2

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

@@ -1,7 +1,7 @@
+import { isModelCornersVertexAttributeValid, useModelCornersVertexAttribute } from "./vertex";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useModelCornersColor } from "./color";
 import { useModelCornersCommonStyle } from "./common";
-import { useModelCornersVertexAttribute } from "./vertex";
 import { useModelCornersVisibility } from "./visibility";
 
 async function setModelCornersDefaultStyle(_id) {
@@ -15,85 +15,117 @@ export function useModelCornersStyle() {
   const modelColorStyle = useModelCornersColor();
   const modelCornersVertexAttribute = useModelCornersVertexAttribute();
 
-  async function applyModelCornersStyle(modelId) {
-    const corners_ids = await dataStore.getCornersGeodeIds(modelId);
-    if (!corners_ids?.length) {
-      return;
-    }
-
+  function applyModelCornersVisibilityStyle(modelId, corners_ids) {
     const visibilityGroups = {};
-    const colorGroups = {};
-    const attributeGroups = {};
-
     for (const corner_id of corners_ids) {
       const style = modelCommonStyle.modelCornerStyle(modelId, corner_id);
-
       const visibility = String(style.visibility);
       if (!visibilityGroups[visibility]) {
         visibilityGroups[visibility] = [];
       }
       visibilityGroups[visibility].push(corner_id);
+    }
+    return Object.entries(visibilityGroups).map(([visibility, ids]) =>
+      modelVisibilityStyle.setModelCornersVisibility(modelId, ids, visibility === "true"),
+    );
+  }
 
-      const coloring = modelColorStyle.modelCornerColoring(modelId, corner_id);
+  function applyModelCornersColoringStyle(modelId, corners_ids) {
+    const activeColoringGroups = {};
+    for (const corner_id of corners_ids) {
       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] = { 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 attributeStyle = coloring[activeColoring];
-        const { name } = attributeStyle;
-        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);
+      if (!activeColoringGroups[activeColoring]) {
+        activeColoringGroups[activeColoring] = [];
       }
+      activeColoringGroups[activeColoring].push(corner_id);
     }
 
-    const promises = [
-      ...Object.entries(visibilityGroups).map(([visibility, ids]) =>
-        modelVisibilityStyle.setModelCornersVisibility(modelId, ids, visibility === "true"),
-      ),
-      ...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 }) => {
-          const attribute = modelCornersVertexAttribute;
-          const setAttributeName = attribute.setModelCornersVertexAttributeName;
-          const setAttributeRange = attribute.setModelCornersVertexAttributeRange;
-          const setAttributeColorMap = attribute.setModelCornersVertexAttributeColorMap;
+    const coloringPromises = [];
 
-          const list = [setAttributeName(modelId, ids, name)];
-          if (minimum !== undefined && maximum !== undefined) {
-            list.push(setAttributeRange(modelId, ids, minimum, maximum));
+    for (const [type, type_corners_ids] of Object.entries(activeColoringGroups)) {
+      if (type === "constant") {
+        const colorGroups = {};
+        for (const corner_id of type_corners_ids) {
+          const color = modelColorStyle.modelCornerColor(modelId, corner_id);
+          const color_key = JSON.stringify(color);
+          if (!colorGroups[color_key]) {
+            colorGroups[color_key] = { color, corners_ids: [] };
           }
-          if (colorMap) {
-            list.push(setAttributeColorMap(modelId, ids, colorMap));
+          colorGroups[color_key].corners_ids.push(corner_id);
+        }
+        coloringPromises.push(
+          ...Object.values(colorGroups).map(({ color, corners_ids: ids }) =>
+            modelColorStyle.setModelCornersColor(modelId, ids, color, "constant"),
+          ),
+        );
+      } else if (type === "random") {
+        coloringPromises.push(
+          modelColorStyle.setModelCornersColor(modelId, type_corners_ids, undefined, "random"),
+        );
+      } else if (type === "vertex") {
+        const vertexGroups = {};
+        for (const corner_id of type_corners_ids) {
+          const name = modelCornersVertexAttribute.modelCornersVertexAttributeName(
+            modelId,
+            corner_id,
+          );
+          const item = modelCornersVertexAttribute.modelCornersVertexAttributeItem(
+            modelId,
+            corner_id,
+          );
+          const [minimum, maximum] = modelCornersVertexAttribute.modelCornersVertexAttributeRange(
+            modelId,
+            corner_id,
+          );
+          const colorMap = modelCornersVertexAttribute.modelCornersVertexAttributeColorMap(
+            modelId,
+            corner_id,
+          );
+          const attribute = { name, item, minimum, maximum, colorMap };
+          if (!isModelCornersVertexAttributeValid(attribute)) {
+            continue;
+          }
+          const key = `${name}_${item}_${colorMap}_${minimum}_${maximum}`;
+          if (!vertexGroups[key]) {
+            vertexGroups[key] = {
+              name,
+              item,
+              minimum,
+              maximum,
+              colorMap,
+              corners_ids: [],
+            };
           }
-          return list;
-        },
-      ),
-    ];
+          vertexGroups[key].corners_ids.push(corner_id);
+        }
+        coloringPromises.push(
+          ...Object.values(vertexGroups).map(
+            ({ name, item, minimum, maximum, colorMap, corners_ids: ids }) =>
+              modelCornersVertexAttribute.setModelCornersVertexAttribute(modelId, ids, {
+                name,
+                item,
+                minimum,
+                maximum,
+                colorMap,
+              }),
+          ),
+        );
+      }
+    }
+
+    return Promise.all(coloringPromises);
+  }
+
+  async function applyModelCornersStyle(modelId) {
+    const corners_ids = await dataStore.getCornersGeodeIds(modelId);
+    if (corners_ids.length === 0) {
+      return;
+    }
 
-    return Promise.all(promises);
+    return Promise.all([
+      applyModelCornersVisibilityStyle(modelId, corners_ids),
+      applyModelCornersColoringStyle(modelId, corners_ids),
+    ]);
   }
 
   return {

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

@@ -8,9 +8,20 @@ import { useModelCornersCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const schema = viewer_schemas.opengeodeweb_viewer.model.corners.attribute.vertex;
+const attributeSchema = viewer_schemas.opengeodeweb_viewer.model.corners.attribute.vertex.attribute;
+
+function isModelCornersVertexAttributeValid({ name, item, minimum, maximum, colorMap }) {
+  return (
+    name !== undefined &&
+    item !== undefined &&
+    minimum !== undefined &&
+    maximum !== undefined &&
+    colorMap !== undefined
+  );
+}
 
-export function useModelCornersVertexAttribute() {
+// oxlint-disable-next-line max-lines-per-function
+function useModelCornersVertexAttribute() {
   const dataStore = useDataStore();
   const modelCornersCommonStyle = useModelCornersCommonStyle();
   const viewerStore = useViewerStore();
@@ -19,16 +30,16 @@ export function useModelCornersVertexAttribute() {
     return modelCornersCommonStyle.modelCornerColoring(modelId, cornerId).vertex;
   }
 
-  function modelCornersVertexAttributeStoredConfig(modelId, cornerId, name) {
+  function modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item) {
     const { storedConfigs } = modelCornersVertexAttribute(modelId, cornerId);
-    if (name in storedConfigs) {
-      return storedConfigs[name];
+    if (storedConfigs && name in storedConfigs && item in storedConfigs[name]) {
+      return storedConfigs[name][item];
     }
-    return setModelCornersVertexAttributeStoredConfig(modelId, [cornerId], name, {
+    return {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    });
+    };
   }
 
   function mutateModelCornersVertexStyle(modelId, cornerIds, values) {
@@ -37,10 +48,13 @@ export function useModelCornersVertexAttribute() {
     });
   }
 
-  function setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, config) {
+  function setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, config) {
     return mutateModelCornersVertexStyle(modelId, cornerIds, {
       storedConfigs: {
-        [name]: config,
+        [name]: {
+          lastItem: item,
+          [item]: config,
+        },
       },
     });
   }
@@ -49,83 +63,119 @@ export function useModelCornersVertexAttribute() {
     return modelCornersVertexAttribute(modelId, cornerId).name;
   }
 
-  async function setModelCornersVertexAttributeName(modelId, cornerIds, name) {
-    const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, cornerIds);
-    const params = { id: modelId, block_ids: viewer_ids, name };
-    return viewerStore.request(
-      { schema: schema.name, params },
-      {
-        response_function: () => mutateModelCornersVertexStyle(modelId, cornerIds, { name }),
-      },
+  function modelCornersVertexAttributeItem(modelId, cornerId) {
+    const vertexAttribute = modelCornersVertexAttribute(modelId, cornerId);
+    return (
+      vertexAttribute.item ??
+      modelCornersVertexAttributeLastItem(modelId, cornerId, vertexAttribute.name)
     );
   }
 
+  function modelCornersVertexAttributeLastItem(modelId, cornerId, name) {
+    const { storedConfigs } = modelCornersVertexAttribute(modelId, cornerId);
+    if (!(name in storedConfigs)) {
+      return 0;
+    }
+    return storedConfigs[name].lastItem;
+  }
+
   function modelCornersVertexAttributeRange(modelId, cornerId) {
     const name = modelCornersVertexAttributeName(modelId, cornerId);
-    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerId, name);
+    const item = modelCornersVertexAttributeItem(modelId, cornerId);
+    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item);
     const { minimum, maximum } = storedConfig;
     return [minimum, maximum];
   }
 
-  async function setModelCornersVertexAttributeRange(modelId, cornerIds, minimum, maximum) {
-    const name = modelCornersVertexAttributeName(modelId, cornerIds[0]);
-    const colorMap = modelCornersVertexAttributeColorMap(modelId, cornerIds[0]);
-    const points = getRGBPointsFromPreset(colorMap);
+  function modelCornersVertexAttributeColorMap(modelId, cornerId) {
+    const name = modelCornersVertexAttributeName(modelId, cornerId);
+    const item = modelCornersVertexAttributeItem(modelId, cornerId);
+    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item);
+    return storedConfig.colorMap;
+  }
 
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, cornerIds);
-      const params = { id: modelId, block_ids: viewer_ids, points, minimum, maximum };
-      return viewerStore.request(
-        { schema: schema.color_map, params },
-        {
-          response_function: () =>
-            setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, {
-              minimum,
-              maximum,
-            }),
-        },
-      );
+  function applyVertexAttribute(modelId, cornerIds) {
+    const name = modelCornersVertexAttributeName(modelId, cornerIds[0]);
+    const item = modelCornersVertexAttributeItem(modelId, cornerIds[0]);
+    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerIds[0], name, item);
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+    };
+    if (isModelCornersVertexAttributeValid(attribute)) {
+      return setModelCornersVertexAttribute(modelId, cornerIds, attribute);
     }
-    return setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, {
+    return Promise.resolve();
+  }
+
+  function setModelCornersVertexAttributeName(modelId, cornerIds, name) {
+    const item = modelCornersVertexAttributeLastItem(modelId, cornerIds[0], name);
+    mutateModelCornersVertexStyle(modelId, cornerIds, { name, item });
+    return applyVertexAttribute(modelId, cornerIds);
+  }
+
+  function setModelCornersVertexAttributeItem(modelId, cornerIds, item) {
+    mutateModelCornersVertexStyle(modelId, cornerIds, { item });
+    return applyVertexAttribute(modelId, cornerIds);
+  }
+
+  function setModelCornersVertexAttributeRange(modelId, cornerIds, minimum, maximum) {
+    const name = modelCornersVertexAttributeName(modelId, cornerIds[0]);
+    const item = modelCornersVertexAttributeItem(modelId, cornerIds[0]);
+    setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, {
       minimum,
       maximum,
     });
+    return applyVertexAttribute(modelId, cornerIds);
   }
 
-  function modelCornersVertexAttributeColorMap(modelId, cornerId) {
-    const name = modelCornersVertexAttributeName(modelId, cornerId);
-    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerId, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
+  function setModelCornersVertexAttributeColorMap(modelId, cornerIds, colorMap) {
+    const name = modelCornersVertexAttributeName(modelId, cornerIds[0]);
+    const item = modelCornersVertexAttributeItem(modelId, cornerIds[0]);
+    setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, { colorMap });
+    return applyVertexAttribute(modelId, cornerIds);
   }
 
-  async function setModelCornersVertexAttributeColorMap(modelId, cornerIds, colorMap) {
-    const name = modelCornersVertexAttributeName(modelId, cornerIds[0]);
-    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerIds[0], name);
+  async function setModelCornersVertexAttribute(
+    modelId,
+    cornerIds,
+    { name, item, minimum, maximum, colorMap },
+  ) {
+    mutateModelCornersVertexStyle(modelId, cornerIds, { name, item });
+    setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, {
+      minimum,
+      maximum,
+      colorMap,
+    });
     const points = getRGBPointsFromPreset(colorMap);
-    const { minimum, maximum } = storedConfig;
-
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, cornerIds);
-      const params = { id: modelId, block_ids: viewer_ids, points, minimum, maximum };
-      return viewerStore.request(
-        { schema: schema.color_map, params },
-        {
-          response_function: () =>
-            setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, { colorMap }),
-        },
-      );
-    }
-    return setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, { colorMap });
+    const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, cornerIds);
+    const params = {
+      id: modelId,
+      block_ids: corner_viewer_ids,
+      name,
+      item,
+      points,
+      minimum,
+      maximum,
+    };
+    return viewerStore.request({ schema: attributeSchema, params });
   }
 
   return {
     modelCornersVertexAttributeName,
+    modelCornersVertexAttributeItem,
     modelCornersVertexAttributeRange,
     modelCornersVertexAttributeColorMap,
     modelCornersVertexAttributeStoredConfig,
+    setModelCornersVertexAttribute,
     setModelCornersVertexAttributeName,
+    setModelCornersVertexAttributeItem,
     setModelCornersVertexAttributeRange,
     setModelCornersVertexAttributeColorMap,
   };
 }
+
+export { isModelCornersVertexAttributeValid, useModelCornersVertexAttribute };

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

@@ -1,7 +1,7 @@
+import { isModelLinesEdgeAttributeValid, useModelLinesEdgeAttribute } from "./edge";
+import { isModelLinesVertexAttributeValid, useModelLinesVertexAttribute } from "./vertex";
 import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
 import { useModelLinesCommonStyle } from "./common";
-import { useModelLinesEdgeAttribute } from "./edge";
-import { useModelLinesVertexAttribute } from "./vertex";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 const schema = viewer_schemas.opengeodeweb_viewer.model.lines.color;
@@ -39,43 +39,38 @@ export function useModelLinesColor() {
 
     if (activeColoring === "vertex") {
       const name = modelLinesVertexAttribute.modelLinesVertexAttributeName(modelId, lines_ids[0]);
-      await modelLinesVertexAttribute.setModelLinesVertexAttributeName(modelId, lines_ids, name);
-      const [min, max] = modelLinesVertexAttribute.modelLinesVertexAttributeRange(
+      const item = modelLinesVertexAttribute.modelLinesVertexAttributeItem(modelId, lines_ids[0]);
+      const [minimum, maximum] = modelLinesVertexAttribute.modelLinesVertexAttributeRange(
         modelId,
         lines_ids[0],
       );
-      await modelLinesVertexAttribute.setModelLinesVertexAttributeRange(
-        modelId,
-        lines_ids,
-        min,
-        max,
-      );
       const colorMap = modelLinesVertexAttribute.modelLinesVertexAttributeColorMap(
         modelId,
         lines_ids[0],
       );
-      await modelLinesVertexAttribute.setModelLinesVertexAttributeColorMap(
-        modelId,
-        lines_ids,
-        colorMap,
-      );
+      const attribute = { name, item, minimum, maximum, colorMap };
+      if (isModelLinesVertexAttributeValid(attribute)) {
+        return modelLinesVertexAttribute.setModelLinesVertexAttribute(
+          modelId,
+          lines_ids,
+          attribute,
+        );
+      }
     } else if (activeColoring === "edge") {
       const name = modelLinesEdgeAttribute.modelLinesEdgeAttributeName(modelId, lines_ids[0]);
-      await modelLinesEdgeAttribute.setModelLinesEdgeAttributeName(modelId, lines_ids, name);
-      const [min, max] = modelLinesEdgeAttribute.modelLinesEdgeAttributeRange(
+      const item = modelLinesEdgeAttribute.modelLinesEdgeAttributeItem(modelId, lines_ids[0]);
+      const [minimum, maximum] = modelLinesEdgeAttribute.modelLinesEdgeAttributeRange(
         modelId,
         lines_ids[0],
       );
-      await modelLinesEdgeAttribute.setModelLinesEdgeAttributeRange(modelId, lines_ids, min, max);
       const colorMap = modelLinesEdgeAttribute.modelLinesEdgeAttributeColorMap(
         modelId,
         lines_ids[0],
       );
-      await modelLinesEdgeAttribute.setModelLinesEdgeAttributeColorMap(
-        modelId,
-        lines_ids,
-        colorMap,
-      );
+      const attribute = { name, item, minimum, maximum, colorMap };
+      if (isModelLinesEdgeAttributeValid(attribute)) {
+        return modelLinesEdgeAttribute.setModelLinesEdgeAttribute(modelId, lines_ids, attribute);
+      }
     }
   }