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

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

@@ -10,14 +10,37 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 const meshPointsVertexAttributeSchemas =
   viewer_schemas.opengeodeweb_viewer.mesh.points.attribute.vertex;
 
+function isMeshPointsVertexAttributeValid({ 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 useMeshPointsVertexAttributeConfig() {
+function useMeshPointsVertexAttributeStyle() {
+  const viewerStore = useViewerStore();
   const meshPointsCommonStyle = useMeshPointsCommonStyle();
 
   function meshPointsVertexAttribute(id) {
     return meshPointsCommonStyle.meshPointsColoring(id).vertex;
   }
 
+  function meshPointsVertexAttributeStoredConfig(id, name, item) {
+    const { storedConfigs } = meshPointsVertexAttribute(id);
+    if (storedConfigs && name in storedConfigs && item in storedConfigs[name]) {
+      return storedConfigs[name][item];
+    }
+    return {
+      minimum: undefined,
+      maximum: undefined,
+      colorMap: undefined,
+    };
+  }
+
   function mutateMeshPointsVertexStyle(id, values) {
     return meshPointsCommonStyle.mutateMeshPointsStyle(id, {
       coloring: {
@@ -26,136 +49,110 @@ function useMeshPointsVertexAttributeConfig() {
     });
   }
 
-  function setMeshPointsVertexAttributeStoredConfig(id, name, config) {
+  function setMeshPointsVertexAttributeStoredConfig(id, name, item, config) {
     return mutateMeshPointsVertexStyle(id, {
       storedConfigs: {
-        [name]: config,
+        [name]: {
+          lastItem: item,
+          [item]: config,
+        },
       },
     });
   }
 
-  function meshPointsVertexAttributeStoredConfig(id, name) {
-    const { storedConfigs } = meshPointsVertexAttribute(id);
-    if (name in storedConfigs) {
-      return storedConfigs[name];
+  function applyVertexAttribute(id) {
+    const name = meshPointsVertexAttributeName(id);
+    const item = meshPointsVertexAttributeItem(id);
+    const storedConfig = meshPointsVertexAttributeStoredConfig(id, name, item);
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+    };
+    if (isMeshPointsVertexAttributeValid(attribute)) {
+      return setMeshPointsVertexAttribute(id, attribute);
     }
-    return setMeshPointsVertexAttributeStoredConfig(id, name, {
-      minimum: undefined,
-      maximum: undefined,
-      colorMap: undefined,
-    });
   }
 
   function meshPointsVertexAttributeName(id) {
     return meshPointsVertexAttribute(id).name;
   }
 
-  function meshPointsVertexAttributeRange(id) {
-    const name = meshPointsVertexAttributeName(id);
-    const storedConfig = meshPointsVertexAttributeStoredConfig(id, name);
-    const { minimum, maximum } = storedConfig;
-    return [minimum, maximum];
+  function setMeshPointsVertexAttributeName(id, name) {
+    const item = meshPointsVertexAttributeLastItem(id, name);
+    mutateMeshPointsVertexStyle(id, { name, item });
+    return applyVertexAttribute(id);
   }
 
-  function meshPointsVertexAttributeColorMap(id) {
-    const name = meshPointsVertexAttributeName(id);
-    const storedConfig = meshPointsVertexAttributeStoredConfig(id, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
+  function meshPointsVertexAttributeItem(id) {
+    const { item, name } = meshPointsVertexAttribute(id);
+    return item ?? meshPointsVertexAttributeLastItem(id, name);
   }
 
-  return {
-    meshPointsVertexAttribute,
-    meshPointsVertexAttributeStoredConfig,
-    setMeshPointsVertexAttributeStoredConfig,
-    mutateMeshPointsVertexStyle,
-    meshPointsVertexAttributeName,
-    meshPointsVertexAttributeRange,
-    meshPointsVertexAttributeColorMap,
-  };
-}
+  function setMeshPointsVertexAttributeItem(id, item) {
+    mutateMeshPointsVertexStyle(id, { item });
+    return applyVertexAttribute(id);
+  }
 
-// oxlint-disable-next-line max-lines-per-function
-function useMeshPointsVertexAttributeActions() {
-  const viewerStore = useViewerStore();
-  const config = useMeshPointsVertexAttributeConfig();
+  function meshPointsVertexAttributeLastItem(id, name) {
+    const { storedConfigs } = meshPointsVertexAttribute(id);
+    if (storedConfigs && name in storedConfigs) {
+      return storedConfigs[name].lastItem;
+    }
+    return 0;
+  }
 
-  function setMeshPointsVertexAttributeName(id, name) {
-    const schema = meshPointsVertexAttributeSchemas.name;
-    const params = { id, name };
-    return viewerStore.request(
-      { schema, params },
-      {
-        response_function: () => {
-          const updates = { name };
-          const vertex = config.meshPointsVertexAttribute(id);
-          if (!(name in vertex.storedConfigs)) {
-            updates.storedConfigs = {
-              [name]: {
-                minimum: undefined,
-                maximum: undefined,
-                colorMap: undefined,
-              },
-            };
-          }
-          return config.mutateMeshPointsVertexStyle(id, updates);
-        },
-      },
-    );
+  function meshPointsVertexAttributeRange(id) {
+    const name = meshPointsVertexAttributeName(id);
+    const item = meshPointsVertexAttributeItem(id);
+    const storedConfig = meshPointsVertexAttributeStoredConfig(id, name, item);
+    return [storedConfig.minimum, storedConfig.maximum];
   }
 
   function setMeshPointsVertexAttributeRange(id, minimum, maximum) {
-    const name = config.meshPointsVertexAttributeName(id);
-    const points = getRGBPointsFromPreset(config.meshPointsVertexAttributeColorMap(id));
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshPointsVertexAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        { schema, params },
-        {
-          response_function: () =>
-            config.setMeshPointsVertexAttributeStoredConfig(id, name, { minimum, maximum }),
-        },
-      );
-    }
-    return config.setMeshPointsVertexAttributeStoredConfig(id, name, {
-      minimum,
-      maximum,
-    });
+    const name = meshPointsVertexAttributeName(id);
+    const item = meshPointsVertexAttributeItem(id);
+    setMeshPointsVertexAttributeStoredConfig(id, name, item, { minimum, maximum });
+    return applyVertexAttribute(id);
+  }
+
+  function meshPointsVertexAttributeColorMap(id) {
+    const name = meshPointsVertexAttributeName(id);
+    const item = meshPointsVertexAttributeItem(id);
+    const storedConfig = meshPointsVertexAttributeStoredConfig(id, name, item);
+    return storedConfig.colorMap;
   }
 
   function setMeshPointsVertexAttributeColorMap(id, colorMap) {
-    const name = config.meshPointsVertexAttributeName(id);
-    const storedConfig = config.meshPointsVertexAttributeStoredConfig(id, name);
+    const name = meshPointsVertexAttributeName(id);
+    const item = meshPointsVertexAttributeItem(id);
+    setMeshPointsVertexAttributeStoredConfig(id, name, item, { colorMap });
+    return applyVertexAttribute(id);
+  }
+
+  function setMeshPointsVertexAttribute(id, { name, item, minimum, maximum, colorMap }) {
+    mutateMeshPointsVertexStyle(id, { name, item });
+    setMeshPointsVertexAttributeStoredConfig(id, name, item, { minimum, maximum, colorMap });
     const points = getRGBPointsFromPreset(colorMap);
-    const { minimum, maximum } = storedConfig;
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshPointsVertexAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        { schema, params },
-        {
-          response_function: () =>
-            config.setMeshPointsVertexAttributeStoredConfig(id, name, { colorMap }),
-        },
-      );
-    }
-    return config.setMeshPointsVertexAttributeStoredConfig(id, name, { colorMap });
+    const schema = meshPointsVertexAttributeSchemas.attribute;
+    const params = { id, name, item, points, minimum, maximum };
+    return viewerStore.request({ schema, params });
   }
 
   return {
+    meshPointsVertexAttributeName,
+    meshPointsVertexAttributeItem,
+    meshPointsVertexAttributeRange,
+    meshPointsVertexAttributeColorMap,
+    meshPointsVertexAttributeStoredConfig,
+    setMeshPointsVertexAttribute,
     setMeshPointsVertexAttributeName,
+    setMeshPointsVertexAttributeItem,
     setMeshPointsVertexAttributeRange,
     setMeshPointsVertexAttributeColorMap,
   };
 }
 
-export function useMeshPointsVertexAttributeStyle() {
-  const config = useMeshPointsVertexAttributeConfig();
-  const actions = useMeshPointsVertexAttributeActions();
-
-  return {
-    ...config,
-    ...actions,
-  };
-}
+export { isMeshPointsVertexAttributeValid, useMeshPointsVertexAttributeStyle };

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

@@ -1,11 +1,14 @@
 // Third party imports
 
 // Local imports
+import {
+  isMeshPolygonsPolygonAttributeValid,
+  useMeshPolygonsPolygonAttributeStyle,
+} from "./polygon";
+import { isMeshPolygonsVertexAttributeValid, useMeshPolygonsVertexAttributeStyle } from "./vertex";
 import { useMeshPolygonsColorStyle } from "./color";
 import { useMeshPolygonsCommonStyle } from "./common";
-import { useMeshPolygonsPolygonAttributeStyle } from "./polygon";
 import { useMeshPolygonsTexturesStyle } from "./textures";
-import { useMeshPolygonsVertexAttributeStyle } from "./vertex";
 import { useMeshPolygonsVisibilityStyle } from "./visibility";
 
 // Local constants
@@ -41,23 +44,30 @@ function useMeshPolygonsColoringStyle() {
     }
     if (type === "vertex") {
       const name = meshPolygonsVertexAttributeStyle.meshPolygonsVertexAttributeName(id);
-      const { colorMap } = meshPolygonsVertexAttributeStyle.meshPolygonsVertexAttributeStoredConfig(
-        id,
-        name,
-      );
-      return Promise.all([
-        meshPolygonsVertexAttributeStyle.setMeshPolygonsVertexAttributeName(id, name),
-        meshPolygonsVertexAttributeStyle.setMeshPolygonsVertexAttributeColorMap(id, colorMap),
-      ]);
+      const item = meshPolygonsVertexAttributeStyle.meshPolygonsVertexAttributeItem(id);
+      const [minimum, maximum] =
+        meshPolygonsVertexAttributeStyle.meshPolygonsVertexAttributeRange(id);
+      const colorMap = meshPolygonsVertexAttributeStyle.meshPolygonsVertexAttributeColorMap(id);
+      const vertex_attribute = { name, item, minimum, maximum, colorMap };
+      if (!isMeshPolygonsVertexAttributeValid(vertex_attribute)) {
+        return;
+      }
+      return meshPolygonsVertexAttributeStyle.setMeshPolygonsVertexAttribute(id, vertex_attribute);
     }
     if (type === "polygon") {
       const name = meshPolygonsPolygonAttributeStyle.meshPolygonsPolygonAttributeName(id);
-      const { colorMap } =
-        meshPolygonsPolygonAttributeStyle.meshPolygonsPolygonAttributeStoredConfig(id, name);
-      return Promise.all([
-        meshPolygonsPolygonAttributeStyle.setMeshPolygonsPolygonAttributeName(id, name),
-        meshPolygonsPolygonAttributeStyle.setMeshPolygonsPolygonAttributeColorMap(id, colorMap),
-      ]);
+      const item = meshPolygonsPolygonAttributeStyle.meshPolygonsPolygonAttributeItem(id);
+      const [minimum, maximum] =
+        meshPolygonsPolygonAttributeStyle.meshPolygonsPolygonAttributeRange(id);
+      const colorMap = meshPolygonsPolygonAttributeStyle.meshPolygonsPolygonAttributeColorMap(id);
+      const polygon_attribute = { name, item, minimum, maximum, colorMap };
+      if (!isMeshPolygonsPolygonAttributeValid(polygon_attribute)) {
+        return;
+      }
+      return meshPolygonsPolygonAttributeStyle.setMeshPolygonsPolygonAttribute(
+        id,
+        polygon_attribute,
+      );
     }
     throw new Error(`Unknown mesh polygons coloring type: ${type}`);
   }

package/internal/stores/data_style/mesh/polygons/polygon.js

@@ -10,25 +10,39 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 const meshPolygonsPolygonAttributeSchemas =
   viewer_schemas.opengeodeweb_viewer.mesh.polygons.attribute.polygon;
 
+function isMeshPolygonsPolygonAttributeValid({ 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 useMeshPolygonsPolygonAttributeStyle() {
+function useMeshPolygonsPolygonAttributeStyle() {
   const viewerStore = useViewerStore();
   const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle();
 
+  function meshPolygonsColoring(id) {
+    return meshPolygonsCommonStyle.meshPolygonsStyle(id).coloring;
+  }
+
   function meshPolygonsPolygonAttribute(id) {
-    return meshPolygonsCommonStyle.meshPolygonsColoring(id).polygon;
+    return meshPolygonsColoring(id).polygon;
   }
 
-  function meshPolygonsPolygonAttributeStoredConfig(id, name) {
+  function meshPolygonsPolygonAttributeStoredConfig(id, name, item) {
     const { storedConfigs } = meshPolygonsPolygonAttribute(id);
-    if (name in storedConfigs) {
-      return storedConfigs[name];
+    if (storedConfigs && name in storedConfigs && item in storedConfigs[name]) {
+      return storedConfigs[name][item];
     }
-    return setMeshPolygonsPolygonAttributeStoredConfig(id, name, {
+    return {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    });
+    };
   }
 
   function mutateMeshPolygonsPolygonStyle(id, values) {
@@ -39,102 +53,110 @@ export function useMeshPolygonsPolygonAttributeStyle() {
     });
   }
 
-  function setMeshPolygonsPolygonAttributeStoredConfig(id, name, config) {
+  function setMeshPolygonsPolygonAttributeStoredConfig(id, name, item, config) {
     return mutateMeshPolygonsPolygonStyle(id, {
       storedConfigs: {
-        [name]: config,
+        [name]: {
+          lastItem: item,
+          [item]: config,
+        },
       },
     });
   }
 
+  function applyPolygonAttribute(id) {
+    const name = meshPolygonsPolygonAttributeName(id);
+    const item = meshPolygonsPolygonAttributeItem(id);
+    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name, item);
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+    };
+    if (isMeshPolygonsPolygonAttributeValid(attribute)) {
+      return setMeshPolygonsPolygonAttribute(id, attribute);
+    }
+  }
+
   function meshPolygonsPolygonAttributeName(id) {
     return meshPolygonsPolygonAttribute(id).name;
   }
 
   function setMeshPolygonsPolygonAttributeName(id, name) {
-    const schema = meshPolygonsPolygonAttributeSchemas.name;
-    const params = { id, name };
-    return viewerStore.request(
-      { schema, params },
-      {
-        response_function: () => {
-          const updates = { name };
-          const polygon = meshPolygonsPolygonAttribute(id);
-          if (!(name in polygon.storedConfigs)) {
-            updates.storedConfigs = {
-              [name]: {
-                minimum: undefined,
-                maximum: undefined,
-                colorMap: undefined,
-              },
-            };
-          }
-          return mutateMeshPolygonsPolygonStyle(id, updates);
-        },
-      },
-    );
+    const item = meshPolygonsPolygonAttributeLastItem(id, name);
+    mutateMeshPolygonsPolygonStyle(id, { name, item });
+    return applyPolygonAttribute(id);
+  }
+
+  function meshPolygonsPolygonAttributeItem(id) {
+    const { item, name } = meshPolygonsPolygonAttribute(id);
+    return item ?? meshPolygonsPolygonAttributeLastItem(id, name);
+  }
+
+  function setMeshPolygonsPolygonAttributeItem(id, item) {
+    mutateMeshPolygonsPolygonStyle(id, { item });
+    return applyPolygonAttribute(id);
+  }
+
+  function meshPolygonsPolygonAttributeLastItem(id, name) {
+    const { storedConfigs } = meshPolygonsPolygonAttribute(id);
+    if (storedConfigs && name in storedConfigs) {
+      return storedConfigs[name].lastItem;
+    }
+    return 0;
   }
 
   function meshPolygonsPolygonAttributeRange(id) {
     const name = meshPolygonsPolygonAttributeName(id);
-    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name);
-    const { minimum, maximum } = storedConfig;
-    return [minimum, maximum];
+    const item = meshPolygonsPolygonAttributeItem(id);
+    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name, item);
+    return [storedConfig.minimum, storedConfig.maximum];
   }
 
   function setMeshPolygonsPolygonAttributeRange(id, minimum, maximum) {
     const name = meshPolygonsPolygonAttributeName(id);
-    const points = getRGBPointsFromPreset(meshPolygonsPolygonAttributeColorMap(id));
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshPolygonsPolygonAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        { schema, params },
-        {
-          response_function: () =>
-            setMeshPolygonsPolygonAttributeStoredConfig(id, name, { minimum, maximum }),
-        },
-      );
-    }
-    return setMeshPolygonsPolygonAttributeStoredConfig(id, name, {
-      minimum,
-      maximum,
-    });
+    const item = meshPolygonsPolygonAttributeItem(id);
+    setMeshPolygonsPolygonAttributeStoredConfig(id, name, item, { minimum, maximum });
+    return applyPolygonAttribute(id);
   }
 
   function meshPolygonsPolygonAttributeColorMap(id) {
     const name = meshPolygonsPolygonAttributeName(id);
-    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
+    const item = meshPolygonsPolygonAttributeItem(id);
+    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name, item);
+    return storedConfig.colorMap;
   }
 
   function setMeshPolygonsPolygonAttributeColorMap(id, colorMap) {
     const name = meshPolygonsPolygonAttributeName(id);
-    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name);
+    const item = meshPolygonsPolygonAttributeItem(id);
+    setMeshPolygonsPolygonAttributeStoredConfig(id, name, item, { colorMap });
+    return applyPolygonAttribute(id);
+  }
+
+  function setMeshPolygonsPolygonAttribute(id, { name, item, minimum, maximum, colorMap }) {
+    mutateMeshPolygonsPolygonStyle(id, { name, item });
+    setMeshPolygonsPolygonAttributeStoredConfig(id, name, item, { minimum, maximum, colorMap });
     const points = getRGBPointsFromPreset(colorMap);
-    const { minimum, maximum } = storedConfig;
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshPolygonsPolygonAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        { schema, params },
-        {
-          response_function: () =>
-            setMeshPolygonsPolygonAttributeStoredConfig(id, name, { colorMap }),
-        },
-      );
-    }
-    return setMeshPolygonsPolygonAttributeStoredConfig(id, name, { colorMap });
+    const schema = meshPolygonsPolygonAttributeSchemas.attribute;
+    const params = { id, name, item, points, minimum, maximum };
+    return viewerStore.request({ schema, params });
   }
 
   return {
     meshPolygonsPolygonAttributeName,
+    meshPolygonsPolygonAttributeItem,
     meshPolygonsPolygonAttributeRange,
     meshPolygonsPolygonAttributeColorMap,
     meshPolygonsPolygonAttributeStoredConfig,
+    setMeshPolygonsPolygonAttribute,
     setMeshPolygonsPolygonAttributeName,
+    setMeshPolygonsPolygonAttributeItem,
     setMeshPolygonsPolygonAttributeRange,
     setMeshPolygonsPolygonAttributeColorMap,
   };
 }
+
+export { isMeshPolygonsPolygonAttributeValid, useMeshPolygonsPolygonAttributeStyle };