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

package/internal/stores/data_style/mesh/cells/cell.js

@@ -9,8 +9,18 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const meshCellsCellAttributeSchemas = viewer_schemas.opengeodeweb_viewer.mesh.cells.attribute.cell;
 
+function isMeshCellsCellAttributeValid({ name, item, minimum, maximum, colorMap }) {
+  return (
+    name !== undefined &&
+    item !== undefined &&
+    minimum !== undefined &&
+    maximum !== undefined &&
+    colorMap !== undefined
+  );
+}
+
 // oxlint-disable-next-line max-lines-per-function
-export function useMeshCellsCellAttributeStyle() {
+function useMeshCellsCellAttributeStyle() {
   const viewerStore = useViewerStore();
   const meshCellsCommonStyle = useMeshCellsCommonStyle();
 
@@ -18,106 +28,130 @@ export function useMeshCellsCellAttributeStyle() {
     return meshCellsCommonStyle.meshCellsColoring(id).cell;
   }
 
-  function meshCellsCellAttributeStoredConfig(id, name) {
+  function meshCellsCellAttributeStoredConfig(id, name, item) {
     const { storedConfigs } = meshCellsCellAttribute(id);
-    if (name in storedConfigs) {
-      return storedConfigs[name];
+    if (storedConfigs && name in storedConfigs && item in storedConfigs[name]) {
+      return storedConfigs[name][item];
     }
-    return setMeshCellsCellAttributeStoredConfig(id, name, {
+    return {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
+    };
+  }
+
+  function mutateMeshCellsCellStyle(id, values) {
+    return meshCellsCommonStyle.mutateMeshCellsStyle(id, {
+      coloring: {
+        cell: values,
+      },
     });
   }
 
-  function setMeshCellsCellAttributeStoredConfig(id, name, config) {
-    return meshCellsCommonStyle.mutateMeshCellsCellStyle(id, {
+  function setMeshCellsCellAttributeStoredConfig(id, name, item, config) {
+    return mutateMeshCellsCellStyle(id, {
       storedConfigs: {
-        [name]: config,
+        [name]: {
+          lastItem: item,
+          [item]: config,
+        },
       },
     });
   }
 
+  function applyCellAttribute(id) {
+    const name = meshCellsCellAttributeName(id);
+    const item = meshCellsCellAttributeItem(id);
+    const storedConfig = meshCellsCellAttributeStoredConfig(id, name, item);
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+    };
+    if (isMeshCellsCellAttributeValid(attribute)) {
+      return setMeshCellsCellAttribute(id, attribute);
+    }
+  }
+
   function meshCellsCellAttributeName(id) {
     return meshCellsCellAttribute(id).name;
   }
 
-  function setMeshCellsCellAttributeName(id, name) {
-    const schema = meshCellsCellAttributeSchemas.name;
-    const params = { id, name };
-    return viewerStore.request(
-      {
-        schema,
-        params,
-      },
-      {
-        response_function: () => meshCellsCommonStyle.mutateMeshCellsCellStyle(id, { name }),
-      },
-    );
+  async function setMeshCellsCellAttributeName(id, name) {
+    const item = meshCellsCellAttributeLastItem(id, name);
+    await mutateMeshCellsCellStyle(id, { name, item });
+    return applyCellAttribute(id);
+  }
+
+  function meshCellsCellAttributeItem(id) {
+    const { item, name } = meshCellsCellAttribute(id);
+    return item ?? meshCellsCellAttributeLastItem(id, name);
+  }
+
+  async function setMeshCellsCellAttributeItem(id, item) {
+    await mutateMeshCellsCellStyle(id, { item });
+    return applyCellAttribute(id);
+  }
+
+  function meshCellsCellAttributeLastItem(id, name) {
+    const { storedConfigs } = meshCellsCellAttribute(id);
+    if (storedConfigs && name in storedConfigs) {
+      return storedConfigs[name].lastItem;
+    }
+    return 0;
   }
 
   function meshCellsCellAttributeRange(id) {
     const name = meshCellsCellAttributeName(id);
-    const storedConfig = meshCellsCellAttributeStoredConfig(id, name);
-    const { minimum, maximum } = storedConfig;
-    return [minimum, maximum];
+    const item = meshCellsCellAttributeItem(id);
+    const storedConfig = meshCellsCellAttributeStoredConfig(id, name, item);
+    return [storedConfig.minimum, storedConfig.maximum];
   }
 
-  function setMeshCellsCellAttributeRange(id, minimum, maximum) {
+  async function setMeshCellsCellAttributeRange(id, minimum, maximum) {
     const name = meshCellsCellAttributeName(id);
-    const points = getRGBPointsFromPreset(meshCellsCellAttributeColorMap(id));
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshCellsCellAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        {
-          schema,
-          params,
-        },
-        {
-          response_function: () =>
-            setMeshCellsCellAttributeStoredConfig(id, name, { minimum, maximum }),
-        },
-      );
-    }
-    return setMeshCellsCellAttributeStoredConfig(id, name, { minimum, maximum });
+    const item = meshCellsCellAttributeItem(id);
+    await setMeshCellsCellAttributeStoredConfig(id, name, item, { minimum, maximum });
+    return applyCellAttribute(id);
   }
 
   function meshCellsCellAttributeColorMap(id) {
     const name = meshCellsCellAttributeName(id);
-    const storedConfig = meshCellsCellAttributeStoredConfig(id, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
+    const item = meshCellsCellAttributeItem(id);
+    const storedConfig = meshCellsCellAttributeStoredConfig(id, name, item);
+    return storedConfig.colorMap;
   }
 
-  function setMeshCellsCellAttributeColorMap(id, colorMap) {
+  async function setMeshCellsCellAttributeColorMap(id, colorMap) {
     const name = meshCellsCellAttributeName(id);
-    const storedConfig = meshCellsCellAttributeStoredConfig(id, name);
+    const item = meshCellsCellAttributeItem(id);
+    await setMeshCellsCellAttributeStoredConfig(id, name, item, { colorMap });
+    return applyCellAttribute(id);
+  }
+
+  function setMeshCellsCellAttribute(id, { name, item, minimum, maximum, colorMap }) {
+    mutateMeshCellsCellStyle(id, { name, item });
+    setMeshCellsCellAttributeStoredConfig(id, name, item, { minimum, maximum, colorMap });
     const points = getRGBPointsFromPreset(colorMap);
-    const { minimum, maximum } = storedConfig;
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshCellsCellAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        {
-          schema,
-          params,
-        },
-        {
-          response_function: () => setMeshCellsCellAttributeStoredConfig(id, name, { colorMap }),
-        },
-      );
-    }
-    return setMeshCellsCellAttributeStoredConfig(id, name, { colorMap });
+    const schema = meshCellsCellAttributeSchemas.attribute;
+    const params = { id, name, item, points, minimum, maximum };
+    return viewerStore.request({ schema, params });
   }
 
   return {
     meshCellsCellAttributeName,
+    meshCellsCellAttributeItem,
     meshCellsCellAttributeRange,
     meshCellsCellAttributeColorMap,
     meshCellsCellAttributeStoredConfig,
+    setMeshCellsCellAttribute,
     setMeshCellsCellAttributeName,
+    setMeshCellsCellAttributeItem,
     setMeshCellsCellAttributeRange,
     setMeshCellsCellAttributeColorMap,
   };
 }
+
+export { isMeshCellsCellAttributeValid, useMeshCellsCellAttributeStyle };

package/internal/stores/data_style/mesh/cells/index.js

@@ -1,11 +1,11 @@
 // Third party imports
 
 // Local imports
-import { useMeshCellsCellAttributeStyle } from "./cell";
+import { isMeshCellsCellAttributeValid, useMeshCellsCellAttributeStyle } from "./cell";
+import { isMeshCellsVertexAttributeValid, useMeshCellsVertexAttributeStyle } from "./vertex";
 import { useMeshCellsColorStyle } from "./color";
 import { useMeshCellsCommonStyle } from "./common";
 import { useMeshCellsTexturesStyle } from "./textures";
-import { useMeshCellsVertexAttributeStyle } from "./vertex";
 import { useMeshCellsVisibilityStyle } from "./visibility";
 
 // Local constants
@@ -30,32 +30,31 @@ export function useMeshCellsStyle() {
     await meshCellsCommonStyle.mutateMeshCellsStyle(id, {
       coloring: { active: type },
     });
-    console.log(setMeshCellsActiveColoring.name, { id }, type);
     if (type === "constant") {
       return meshCellsColorStyle.setMeshCellsColor(id, meshCellsColorStyle.meshCellsColor(id));
-    }
-    if (type === "textures") {
+    } else if (type === "textures") {
       const textures = meshCellsTexturesStore.meshCellsTextures(id);
       return meshCellsTexturesStore.setMeshCellsTextures(id, textures);
-    }
-    if (type === "vertex") {
+    } else if (type === "vertex") {
       const name = meshCellsVertexAttributeStyle.meshCellsVertexAttributeName(id);
-      const { colorMap } = meshCellsVertexAttributeStyle.meshCellsVertexAttributeStoredConfig(
-        id,
-        name,
-      );
-      return Promise.all([
-        meshCellsVertexAttributeStyle.setMeshCellsVertexAttributeName(id, name),
-        meshCellsVertexAttributeStyle.setMeshCellsVertexAttributeColorMap(id, colorMap),
-      ]);
-    }
-    if (type === "cell") {
+      const item = meshCellsVertexAttributeStyle.meshCellsVertexAttributeItem(id);
+      const [minimum, maximum] = meshCellsVertexAttributeStyle.meshCellsVertexAttributeRange(id);
+      const colorMap = meshCellsVertexAttributeStyle.meshCellsVertexAttributeColorMap(id);
+      const vertex_attribute = { name, item, minimum, maximum, colorMap };
+      if (!isMeshCellsVertexAttributeValid(vertex_attribute)) {
+        return;
+      }
+      return meshCellsVertexAttributeStyle.setMeshCellsVertexAttribute(id, vertex_attribute);
+    } else if (type === "cell") {
       const name = meshCellsCellAttributeStyle.meshCellsCellAttributeName(id);
-      const { colorMap } = meshCellsCellAttributeStyle.meshCellsCellAttributeStoredConfig(id, name);
-      return Promise.all([
-        meshCellsCellAttributeStyle.setMeshCellsCellAttributeName(id, name),
-        meshCellsCellAttributeStyle.setMeshCellsCellAttributeColorMap(id, colorMap),
-      ]);
+      const item = meshCellsCellAttributeStyle.meshCellsCellAttributeItem(id);
+      const [minimum, maximum] = meshCellsCellAttributeStyle.meshCellsCellAttributeRange(id);
+      const colorMap = meshCellsCellAttributeStyle.meshCellsCellAttributeColorMap(id);
+      const cell_attribute = { name, item, minimum, maximum, colorMap };
+      if (!isMeshCellsCellAttributeValid(cell_attribute)) {
+        return;
+      }
+      return meshCellsCellAttributeStyle.setMeshCellsCellAttribute(id, cell_attribute);
     }
     throw new Error(`Unknown mesh cells coloring type: ${type}`);
   }

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

@@ -10,8 +10,18 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 const meshCellsVertexAttributeSchemas =
   viewer_schemas.opengeodeweb_viewer.mesh.cells.attribute.vertex;
 
+function isMeshCellsVertexAttributeValid({ name, item, minimum, maximum, colorMap }) {
+  return (
+    name !== undefined &&
+    item !== undefined &&
+    minimum !== undefined &&
+    maximum !== undefined &&
+    colorMap !== undefined
+  );
+}
+
 // oxlint-disable-next-line max-lines-per-function
-export function useMeshCellsVertexAttributeStyle() {
+function useMeshCellsVertexAttributeStyle() {
   const viewerStore = useViewerStore();
   const meshCellsCommonStyle = useMeshCellsCommonStyle();
 
@@ -19,16 +29,16 @@ export function useMeshCellsVertexAttributeStyle() {
     return meshCellsCommonStyle.meshCellsColoring(id).vertex;
   }
 
-  function meshCellsVertexAttributeStoredConfig(id, name) {
+  function meshCellsVertexAttributeStoredConfig(id, name, item) {
     const { storedConfigs } = meshCellsVertexAttribute(id);
-    if (name in storedConfigs) {
-      return storedConfigs[name];
+    if (storedConfigs && name in storedConfigs && item in storedConfigs[name]) {
+      return storedConfigs[name][item];
     }
-    return setMeshCellsVertexAttributeStoredConfig(id, name, {
+    return {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    });
+    };
   }
 
   function mutateMeshCellsVertexStyle(id, values) {
@@ -39,101 +49,110 @@ export function useMeshCellsVertexAttributeStyle() {
     });
   }
 
-  function setMeshCellsVertexAttributeStoredConfig(id, name, config) {
+  function setMeshCellsVertexAttributeStoredConfig(id, name, item, config) {
     return mutateMeshCellsVertexStyle(id, {
       storedConfigs: {
-        [name]: config,
+        [name]: {
+          lastItem: item,
+          [item]: config,
+        },
       },
     });
   }
 
+  function applyVertexAttribute(id) {
+    const name = meshCellsVertexAttributeName(id);
+    const item = meshCellsVertexAttributeItem(id);
+    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name, item);
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+    };
+    if (isMeshCellsVertexAttributeValid(attribute)) {
+      return setMeshCellsVertexAttribute(id, attribute);
+    }
+  }
+
   function meshCellsVertexAttributeName(id) {
     return meshCellsVertexAttribute(id).name;
   }
 
   function setMeshCellsVertexAttributeName(id, name) {
-    const schema = meshCellsVertexAttributeSchemas.name;
-    const params = { id, name };
-    return viewerStore.request(
-      { schema, params },
-      {
-        response_function: () => {
-          const updates = { name };
-          const vertex = meshCellsVertexAttribute(id);
-          if (!(name in vertex.storedConfigs)) {
-            updates.storedConfigs = {
-              [name]: {
-                minimum: undefined,
-                maximum: undefined,
-                colorMap: undefined,
-              },
-            };
-          }
-          return mutateMeshCellsVertexStyle(id, updates);
-        },
-      },
-    );
+    const item = meshCellsVertexAttributeLastItem(id, name);
+    mutateMeshCellsVertexStyle(id, { name, item });
+    return applyVertexAttribute(id);
+  }
+
+  function meshCellsVertexAttributeItem(id) {
+    const { item, name } = meshCellsVertexAttribute(id);
+    return item ?? meshCellsVertexAttributeLastItem(id, name);
+  }
+
+  function setMeshCellsVertexAttributeItem(id, item) {
+    mutateMeshCellsVertexStyle(id, { item });
+    return applyVertexAttribute(id);
+  }
+
+  function meshCellsVertexAttributeLastItem(id, name) {
+    const { storedConfigs } = meshCellsVertexAttribute(id);
+    if (storedConfigs && name in storedConfigs) {
+      return storedConfigs[name].lastItem;
+    }
+    return 0;
   }
 
   function meshCellsVertexAttributeRange(id) {
     const name = meshCellsVertexAttributeName(id);
-    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name);
-    const { minimum, maximum } = storedConfig;
-    return [minimum, maximum];
+    const item = meshCellsVertexAttributeItem(id);
+    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name, item);
+    return [storedConfig.minimum, storedConfig.maximum];
   }
 
   function setMeshCellsVertexAttributeRange(id, minimum, maximum) {
     const name = meshCellsVertexAttributeName(id);
-    const points = getRGBPointsFromPreset(meshCellsVertexAttributeColorMap(id));
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshCellsVertexAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        { schema, params },
-        {
-          response_function: () =>
-            setMeshCellsVertexAttributeStoredConfig(id, name, { minimum, maximum }),
-        },
-      );
-    }
-    return setMeshCellsVertexAttributeStoredConfig(id, name, {
-      minimum,
-      maximum,
-    });
+    const item = meshCellsVertexAttributeItem(id);
+    setMeshCellsVertexAttributeStoredConfig(id, name, item, { minimum, maximum });
+    return applyVertexAttribute(id);
   }
 
   function meshCellsVertexAttributeColorMap(id) {
     const name = meshCellsVertexAttributeName(id);
-    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
+    const item = meshCellsVertexAttributeItem(id);
+    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name, item);
+    return storedConfig.colorMap;
   }
 
   function setMeshCellsVertexAttributeColorMap(id, colorMap) {
     const name = meshCellsVertexAttributeName(id);
-    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name);
+    const item = meshCellsVertexAttributeItem(id);
+    setMeshCellsVertexAttributeStoredConfig(id, name, item, { colorMap });
+    return applyVertexAttribute(id);
+  }
+
+  function setMeshCellsVertexAttribute(id, { name, item, minimum, maximum, colorMap }) {
+    mutateMeshCellsVertexStyle(id, { name, item });
+    setMeshCellsVertexAttributeStoredConfig(id, name, item, { minimum, maximum, colorMap });
     const points = getRGBPointsFromPreset(colorMap);
-    const { minimum, maximum } = storedConfig;
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshCellsVertexAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        { schema, params },
-        {
-          response_function: () => setMeshCellsVertexAttributeStoredConfig(id, name, { colorMap }),
-        },
-      );
-    }
-    return setMeshCellsVertexAttributeStoredConfig(id, name, { colorMap });
+    const schema = meshCellsVertexAttributeSchemas.attribute;
+    const params = { id, name, item, points, minimum, maximum };
+    return viewerStore.request({ schema, params });
   }
 
   return {
     meshCellsVertexAttributeName,
+    meshCellsVertexAttributeItem,
     meshCellsVertexAttributeRange,
     meshCellsVertexAttributeColorMap,
     meshCellsVertexAttributeStoredConfig,
+    setMeshCellsVertexAttribute,
     setMeshCellsVertexAttributeName,
+    setMeshCellsVertexAttributeItem,
     setMeshCellsVertexAttributeRange,
     setMeshCellsVertexAttributeColorMap,
   };
 }
+
+export { isMeshCellsVertexAttributeValid, useMeshCellsVertexAttributeStyle };