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

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

@@ -10,12 +10,39 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 const meshPolyhedraVertexAttributeSchemas =
   viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.attribute.vertex;
 
+function isMeshPolyhedraVertexAttributeValid({ name, item, minimum, maximum, colorMap }) {
+  return (
+    name !== undefined &&
+    item !== undefined &&
+    minimum !== undefined &&
+    maximum !== undefined &&
+    colorMap !== undefined
+  );
+}
+
 // oxlint-disable-next-line max-lines-per-function
-function useMeshPolyhedraVertexAttributeConfig() {
+function useMeshPolyhedraVertexAttributeStyle() {
+  const viewerStore = useViewerStore();
   const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle();
 
+  function meshPolyhedraColoring(id) {
+    return meshPolyhedraCommonStyle.meshPolyhedraStyle(id).coloring;
+  }
+
   function meshPolyhedraVertexAttribute(id) {
-    return meshPolyhedraCommonStyle.meshPolyhedraColoring(id).vertex;
+    return meshPolyhedraColoring(id).vertex;
+  }
+
+  function meshPolyhedraVertexAttributeStoredConfig(id, name, item) {
+    const { storedConfigs } = meshPolyhedraVertexAttribute(id);
+    if (storedConfigs && name in storedConfigs && item in storedConfigs[name]) {
+      return storedConfigs[name][item];
+    }
+    return {
+      minimum: undefined,
+      maximum: undefined,
+      colorMap: undefined,
+    };
   }
 
   function mutateMeshPolyhedraVertexStyle(id, values) {
@@ -26,139 +53,110 @@ function useMeshPolyhedraVertexAttributeConfig() {
     });
   }
 
-  function setMeshPolyhedraVertexAttributeStoredConfig(id, name, config) {
+  function setMeshPolyhedraVertexAttributeStoredConfig(id, name, item, config) {
     return mutateMeshPolyhedraVertexStyle(id, {
       storedConfigs: {
-        [name]: config,
+        [name]: {
+          lastItem: item,
+          [item]: config,
+        },
       },
     });
   }
 
-  function meshPolyhedraVertexAttributeStoredConfig(id, name) {
-    const { storedConfigs } = meshPolyhedraVertexAttribute(id);
-    if (name in storedConfigs) {
-      return storedConfigs[name];
+  function applyVertexAttribute(id) {
+    const name = meshPolyhedraVertexAttributeName(id);
+    const item = meshPolyhedraVertexAttributeItem(id);
+    const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name, item);
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+    };
+    if (isMeshPolyhedraVertexAttributeValid(attribute)) {
+      return setMeshPolyhedraVertexAttribute(id, attribute);
     }
-    return setMeshPolyhedraVertexAttributeStoredConfig(id, name, {
-      minimum: undefined,
-      maximum: undefined,
-      colorMap: undefined,
-    });
   }
 
   function meshPolyhedraVertexAttributeName(id) {
     return meshPolyhedraVertexAttribute(id).name;
   }
 
-  function meshPolyhedraVertexAttributeRange(id) {
-    const name = meshPolyhedraVertexAttributeName(id);
-    const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name);
-    const { minimum, maximum } = storedConfig;
-    return [minimum, maximum];
+  function setMeshPolyhedraVertexAttributeName(id, name) {
+    const item = meshPolyhedraVertexAttributeLastItem(id, name);
+    mutateMeshPolyhedraVertexStyle(id, { name, item });
+    return applyVertexAttribute(id);
   }
 
-  function meshPolyhedraVertexAttributeColorMap(id) {
-    const name = meshPolyhedraVertexAttributeName(id);
-    const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
+  function meshPolyhedraVertexAttributeItem(id) {
+    const { item, name } = meshPolyhedraVertexAttribute(id);
+    return item ?? meshPolyhedraVertexAttributeLastItem(id, name);
   }
 
-  return {
-    meshPolyhedraVertexAttribute,
-    meshPolyhedraVertexAttributeStoredConfig,
-    setMeshPolyhedraVertexAttributeStoredConfig,
-    mutateMeshPolyhedraVertexStyle,
-    meshPolyhedraVertexAttributeName,
-    meshPolyhedraVertexAttributeRange,
-    meshPolyhedraVertexAttributeColorMap,
-  };
-}
+  function setMeshPolyhedraVertexAttributeItem(id, item) {
+    mutateMeshPolyhedraVertexStyle(id, { item });
+    return applyVertexAttribute(id);
+  }
 
-// oxlint-disable-next-line max-lines-per-function
-function useMeshPolyhedraVertexAttributeActions() {
-  const viewerStore = useViewerStore();
-  const config = useMeshPolyhedraVertexAttributeConfig();
+  function meshPolyhedraVertexAttributeLastItem(id, name) {
+    const { storedConfigs } = meshPolyhedraVertexAttribute(id);
+    if (storedConfigs && name in storedConfigs) {
+      return storedConfigs[name].lastItem;
+    }
+    return 0;
+  }
 
-  function setMeshPolyhedraVertexAttributeName(id, name) {
-    const schema = meshPolyhedraVertexAttributeSchemas.name;
-    const params = { id, name };
-    return viewerStore.request(
-      {
-        schema,
-        params,
-      },
-      {
-        response_function: () => {
-          const updates = { name };
-          const vertex = config.meshPolyhedraVertexAttribute(id);
-          if (!(name in vertex.storedConfigs)) {
-            updates.storedConfigs = {
-              [name]: {
-                minimum: undefined,
-                maximum: undefined,
-                colorMap: undefined,
-              },
-            };
-          }
-          return config.mutateMeshPolyhedraVertexStyle(id, updates);
-        },
-      },
-    );
+  function meshPolyhedraVertexAttributeRange(id) {
+    const name = meshPolyhedraVertexAttributeName(id);
+    const item = meshPolyhedraVertexAttributeItem(id);
+    const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name, item);
+    return [storedConfig.minimum, storedConfig.maximum];
   }
 
   function setMeshPolyhedraVertexAttributeRange(id, minimum, maximum) {
-    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(
-        { schema, params },
-        {
-          response_function: () =>
-            config.setMeshPolyhedraVertexAttributeStoredConfig(id, name, { minimum, maximum }),
-        },
-      );
-    }
-    return config.setMeshPolyhedraVertexAttributeStoredConfig(id, name, {
-      minimum,
-      maximum,
-    });
+    const name = meshPolyhedraVertexAttributeName(id);
+    const item = meshPolyhedraVertexAttributeItem(id);
+    setMeshPolyhedraVertexAttributeStoredConfig(id, name, item, { minimum, maximum });
+    return applyVertexAttribute(id);
+  }
+
+  function meshPolyhedraVertexAttributeColorMap(id) {
+    const name = meshPolyhedraVertexAttributeName(id);
+    const item = meshPolyhedraVertexAttributeItem(id);
+    const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name, item);
+    return storedConfig.colorMap;
   }
 
   function setMeshPolyhedraVertexAttributeColorMap(id, colorMap) {
-    const name = config.meshPolyhedraVertexAttributeName(id);
-    const storedConfig = config.meshPolyhedraVertexAttributeStoredConfig(id, name);
+    const name = meshPolyhedraVertexAttributeName(id);
+    const item = meshPolyhedraVertexAttributeItem(id);
+    setMeshPolyhedraVertexAttributeStoredConfig(id, name, item, { colorMap });
+    return applyVertexAttribute(id);
+  }
+
+  function setMeshPolyhedraVertexAttribute(id, { name, item, minimum, maximum, colorMap }) {
+    mutateMeshPolyhedraVertexStyle(id, { name, item });
+    setMeshPolyhedraVertexAttributeStoredConfig(id, name, item, { minimum, maximum, colorMap });
     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(
-        { schema, params },
-        {
-          response_function: () =>
-            config.setMeshPolyhedraVertexAttributeStoredConfig(id, name, { colorMap }),
-        },
-      );
-    }
-    return config.setMeshPolyhedraVertexAttributeStoredConfig(id, name, { colorMap });
+    const schema = meshPolyhedraVertexAttributeSchemas.attribute;
+    const params = { id, name, item, points, minimum, maximum };
+    return viewerStore.request({ schema, params });
   }
 
   return {
+    meshPolyhedraVertexAttributeName,
+    meshPolyhedraVertexAttributeItem,
+    meshPolyhedraVertexAttributeRange,
+    meshPolyhedraVertexAttributeColorMap,
+    meshPolyhedraVertexAttributeStoredConfig,
+    setMeshPolyhedraVertexAttribute,
     setMeshPolyhedraVertexAttributeName,
+    setMeshPolyhedraVertexAttributeItem,
     setMeshPolyhedraVertexAttributeRange,
     setMeshPolyhedraVertexAttributeColorMap,
   };
 }
 
-export function useMeshPolyhedraVertexAttributeStyle() {
-  const config = useMeshPolyhedraVertexAttributeConfig();
-  const actions = useMeshPolyhedraVertexAttributeActions();
-
-  return {
-    ...config,
-    ...actions,
-  };
-}
+export { isMeshPolyhedraVertexAttributeValid, useMeshPolyhedraVertexAttributeStyle };

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

@@ -1,6 +1,9 @@
+import {
+  isModelBlocksPolyhedronAttributeValid,
+  useModelBlocksPolyhedronAttribute,
+} from "./polyhedron";
+import { isModelBlocksVertexAttributeValid, useModelBlocksVertexAttribute } from "./vertex";
 import { useModelBlocksCommonStyle } from "./common";
-import { useModelBlocksPolyhedronAttribute } from "./polyhedron";
-import { useModelBlocksVertexAttribute } from "./vertex";
 import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
@@ -42,55 +45,51 @@ export function useModelBlocksColor() {
         modelId,
         blocks_ids[0],
       );
-      await modelBlocksVertexAttribute.setModelBlocksVertexAttributeName(modelId, blocks_ids, name);
-      const [min, max] = modelBlocksVertexAttribute.modelBlocksVertexAttributeRange(
+      const item = modelBlocksVertexAttribute.modelBlocksVertexAttributeItem(
         modelId,
         blocks_ids[0],
       );
-      await modelBlocksVertexAttribute.setModelBlocksVertexAttributeRange(
+      const [minimum, maximum] = modelBlocksVertexAttribute.modelBlocksVertexAttributeRange(
         modelId,
-        blocks_ids,
-        min,
-        max,
+        blocks_ids[0],
       );
       const colorMap = modelBlocksVertexAttribute.modelBlocksVertexAttributeColorMap(
         modelId,
         blocks_ids[0],
       );
-      await modelBlocksVertexAttribute.setModelBlocksVertexAttributeColorMap(
-        modelId,
-        blocks_ids,
-        colorMap,
-      );
+      const attribute = { name, item, minimum, maximum, colorMap };
+      if (isModelBlocksVertexAttributeValid(attribute)) {
+        return modelBlocksVertexAttribute.setModelBlocksVertexAttribute(
+          modelId,
+          blocks_ids,
+          attribute,
+        );
+      }
     } else if (activeColoring === "polyhedron") {
       const name = modelBlocksPolyhedronAttribute.modelBlocksPolyhedronAttributeName(
         modelId,
         blocks_ids[0],
       );
-      await modelBlocksPolyhedronAttribute.setModelBlocksPolyhedronAttributeName(
-        modelId,
-        blocks_ids,
-        name,
-      );
-      const [min, max] = modelBlocksPolyhedronAttribute.modelBlocksPolyhedronAttributeRange(
+      const item = modelBlocksPolyhedronAttribute.modelBlocksPolyhedronAttributeItem(
         modelId,
         blocks_ids[0],
       );
-      await modelBlocksPolyhedronAttribute.setModelBlocksPolyhedronAttributeRange(
+      const [minimum, maximum] = modelBlocksPolyhedronAttribute.modelBlocksPolyhedronAttributeRange(
         modelId,
-        blocks_ids,
-        min,
-        max,
+        blocks_ids[0],
       );
       const colorMap = modelBlocksPolyhedronAttribute.modelBlocksPolyhedronAttributeColorMap(
         modelId,
         blocks_ids[0],
       );
-      await modelBlocksPolyhedronAttribute.setModelBlocksPolyhedronAttributeColorMap(
-        modelId,
-        blocks_ids,
-        colorMap,
-      );
+      const attribute = { name, item, minimum, maximum, colorMap };
+      if (isModelBlocksPolyhedronAttributeValid(attribute)) {
+        return modelBlocksPolyhedronAttribute.setModelBlocksPolyhedronAttribute(
+          modelId,
+          blocks_ids,
+          attribute,
+        );
+      }
     }
   }
 

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

@@ -1,8 +1,11 @@
+import {
+  isModelBlocksPolyhedronAttributeValid,
+  useModelBlocksPolyhedronAttribute,
+} from "./polyhedron";
+import { isModelBlocksVertexAttributeValid, useModelBlocksVertexAttribute } from "./vertex";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useModelBlocksColor } from "./color";
 import { useModelBlocksCommonStyle } from "./common";
-import { useModelBlocksPolyhedronAttribute } from "./polyhedron";
-import { useModelBlocksVertexAttribute } from "./vertex";
 import { useModelBlocksVisibility } from "./visibility";
 
 async function setModelBlocksDefaultStyle(_id) {
@@ -17,94 +20,159 @@ export function useModelBlocksStyle() {
   const modelBlocksVertexAttribute = useModelBlocksVertexAttribute();
   const modelBlocksPolyhedronAttribute = useModelBlocksPolyhedronAttribute();
 
-  async function applyModelBlocksStyle(modelId) {
-    const blocks_ids = await dataStore.getBlocksGeodeIds(modelId);
-    if (!blocks_ids?.length) {
-      return;
-    }
-
+  function applyModelBlocksVisibilityStyle(modelId, blocks_ids) {
     const visibilityGroups = {};
-    const colorGroups = {};
-    const attributeGroups = {};
-
     for (const block_id of blocks_ids) {
       const style = modelCommonStyle.modelBlockStyle(modelId, block_id);
-
       const visibility = String(style.visibility);
       if (!visibilityGroups[visibility]) {
         visibilityGroups[visibility] = [];
       }
       visibilityGroups[visibility].push(block_id);
+    }
+    return Promise.all(
+      Object.entries(visibilityGroups).map(([visibility, ids]) =>
+        modelVisibilityStyle.setModelBlocksVisibility(modelId, ids, visibility === "true"),
+      ),
+    );
+  }
 
-      const coloring = modelColorStyle.modelBlockColoring(modelId, block_id);
+  function applyModelBlocksColoringStyle(modelId, blocks_ids) {
+    const activeColoringGroups = {};
+    for (const block_id of blocks_ids) {
       const activeColoring = modelColorStyle.modelBlockActiveColoring(modelId, block_id);
-      if (activeColoring === "constant") {
-        const color = modelColorStyle.modelBlockColor(modelId, block_id);
-        const color_key = JSON.stringify(color);
-        if (!colorGroups[color_key]) {
-          colorGroups[color_key] = { activeColoring, color, blocks_ids: [] };
+      if (!activeColoringGroups[activeColoring]) {
+        activeColoringGroups[activeColoring] = [];
+      }
+      activeColoringGroups[activeColoring].push(block_id);
+    }
+
+    const coloringPromises = [];
+
+    for (const [type, type_blocks_ids] of Object.entries(activeColoringGroups)) {
+      if (type === "constant") {
+        const colorGroups = {};
+        for (const block_id of type_blocks_ids) {
+          const color = modelColorStyle.modelBlockColor(modelId, block_id);
+          const color_key = JSON.stringify(color);
+          if (!colorGroups[color_key]) {
+            colorGroups[color_key] = { color, blocks_ids: [] };
+          }
+          colorGroups[color_key].blocks_ids.push(block_id);
         }
-        colorGroups[color_key].blocks_ids.push(block_id);
-      } else if (activeColoring === "random") {
-        if (!colorGroups["random"]) {
-          colorGroups["random"] = { activeColoring, color: undefined, blocks_ids: [] };
+        coloringPromises.push(
+          ...Object.values(colorGroups).map(({ color, blocks_ids: ids }) =>
+            modelColorStyle.setModelBlocksColor(modelId, ids, color, "constant"),
+          ),
+        );
+      } else if (type === "random") {
+        coloringPromises.push(
+          modelColorStyle.setModelBlocksColor(modelId, type_blocks_ids, undefined, "random"),
+        );
+      } else if (type === "vertex") {
+        const vertexGroups = {};
+        for (const block_id of type_blocks_ids) {
+          const name = modelBlocksVertexAttribute.modelBlocksVertexAttributeName(modelId, block_id);
+          const item = modelBlocksVertexAttribute.modelBlocksVertexAttributeItem(modelId, block_id);
+          const [minimum, maximum] = modelBlocksVertexAttribute.modelBlocksVertexAttributeRange(
+            modelId,
+            block_id,
+          );
+          const colorMap = modelBlocksVertexAttribute.modelBlocksVertexAttributeColorMap(
+            modelId,
+            block_id,
+          );
+          const attribute = { name, item, minimum, maximum, colorMap };
+          if (!isModelBlocksVertexAttributeValid(attribute)) {
+            continue;
+          }
+          const key = `${name}_${item}_${colorMap}_${minimum}_${maximum}`;
+          if (!vertexGroups[key]) {
+            vertexGroups[key] = {
+              name,
+              item,
+              minimum,
+              maximum,
+              colorMap,
+              blocks_ids: [],
+            };
+          }
+          vertexGroups[key].blocks_ids.push(block_id);
         }
-        colorGroups["random"].blocks_ids.push(block_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,
-            blocks_ids: [],
-          };
+        coloringPromises.push(
+          ...Object.values(vertexGroups).map(
+            ({ name, item, minimum, maximum, colorMap, blocks_ids: ids }) =>
+              modelBlocksVertexAttribute.setModelBlocksVertexAttribute(modelId, ids, {
+                name,
+                item,
+                minimum,
+                maximum,
+                colorMap,
+              }),
+          ),
+        );
+      } else if (type === "polyhedron") {
+        const polyhedronGroups = {};
+        for (const block_id of type_blocks_ids) {
+          const name = modelBlocksPolyhedronAttribute.modelBlocksPolyhedronAttributeName(
+            modelId,
+            block_id,
+          );
+          const item = modelBlocksPolyhedronAttribute.modelBlocksPolyhedronAttributeItem(
+            modelId,
+            block_id,
+          );
+          const [minimum, maximum] =
+            modelBlocksPolyhedronAttribute.modelBlocksPolyhedronAttributeRange(modelId, block_id);
+          const colorMap = modelBlocksPolyhedronAttribute.modelBlocksPolyhedronAttributeColorMap(
+            modelId,
+            block_id,
+          );
+          const attribute = { name, item, minimum, maximum, colorMap };
+          if (!isModelBlocksPolyhedronAttributeValid(attribute)) {
+            continue;
+          }
+          const key = `${name}_${item}_${colorMap}_${minimum}_${maximum}`;
+          if (!polyhedronGroups[key]) {
+            polyhedronGroups[key] = {
+              name,
+              item,
+              minimum,
+              maximum,
+              colorMap,
+              blocks_ids: [],
+            };
+          }
+          polyhedronGroups[key].blocks_ids.push(block_id);
         }
-        attributeGroups[attributeGroupKey].blocks_ids.push(block_id);
+        coloringPromises.push(
+          ...Object.values(polyhedronGroups).map(
+            ({ name, item, minimum, maximum, colorMap, blocks_ids: ids }) =>
+              modelBlocksPolyhedronAttribute.setModelBlocksPolyhedronAttribute(modelId, ids, {
+                name,
+                item,
+                minimum,
+                maximum,
+                colorMap,
+              }),
+          ),
+        );
       }
     }
 
-    const promises = [
-      ...Object.entries(visibilityGroups).map(([visibility, ids]) =>
-        modelVisibilityStyle.setModelBlocksVisibility(modelId, ids, visibility === "true"),
-      ),
-      ...Object.values(colorGroups).map(({ activeColoring, color, blocks_ids: ids }) =>
-        modelColorStyle.setModelBlocksColor(modelId, ids, color, activeColoring),
-      ),
-      ...Object.values(attributeGroups).flatMap(
-        ({ activeColoring, name, minimum, maximum, colorMap, blocks_ids: ids }) => {
-          const isVertex = activeColoring === "vertex";
-          const attributeStyle = isVertex
-            ? modelBlocksVertexAttribute
-            : modelBlocksPolyhedronAttribute;
-          const setAttributeName = isVertex
-            ? attributeStyle.setModelBlocksVertexAttributeName
-            : attributeStyle.setModelBlocksPolyhedronAttributeName;
-          const setAttributeRange = isVertex
-            ? attributeStyle.setModelBlocksVertexAttributeRange
-            : attributeStyle.setModelBlocksPolyhedronAttributeRange;
-          const setAttributeColorMap = isVertex
-            ? attributeStyle.setModelBlocksVertexAttributeColorMap
-            : attributeStyle.setModelBlocksPolyhedronAttributeColorMap;
+    return Promise.all(coloringPromises);
+  }
 
-          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;
-        },
-      ),
-    ];
+  async function applyModelBlocksStyle(modelId) {
+    const blocks_ids = await dataStore.getBlocksGeodeIds(modelId);
+    if (blocks_ids.length === 0) {
+      return;
+    }
 
-    return Promise.all(promises);
+    return Promise.all([
+      applyModelBlocksVisibilityStyle(modelId, blocks_ids),
+      applyModelBlocksColoringStyle(modelId, blocks_ids),
+    ]);
   }
 
   return {