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

package/internal/stores/data_style/mesh/edges/edge.js

@@ -9,8 +9,18 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const meshEdgesEdgeAttributeSchemas = viewer_schemas.opengeodeweb_viewer.mesh.edges.attribute.edge;
 
+function isMeshEdgesEdgeAttributeValid({ 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 useMeshEdgesEdgeAttributeStyle() {
+function useMeshEdgesEdgeAttributeStyle() {
   const viewerStore = useViewerStore();
   const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
 
@@ -22,16 +32,16 @@ export function useMeshEdgesEdgeAttributeStyle() {
     return meshEdgesColoring(id).edge;
   }
 
-  function meshEdgesEdgeAttributeStoredConfig(id, name) {
+  function meshEdgesEdgeAttributeStoredConfig(id, name, item) {
     const { storedConfigs } = meshEdgesEdgeAttribute(id);
-    if (name in storedConfigs) {
-      return storedConfigs[name];
+    if (storedConfigs && name in storedConfigs && item in storedConfigs[name]) {
+      return storedConfigs[name][item];
     }
-    return setMeshEdgesEdgeAttributeStoredConfig(id, name, {
+    return {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    });
+    };
   }
 
   function mutateMeshEdgesEdgeStyle(id, values) {
@@ -42,104 +52,110 @@ export function useMeshEdgesEdgeAttributeStyle() {
     });
   }
 
-  function setMeshEdgesEdgeAttributeStoredConfig(id, name, config) {
+  function setMeshEdgesEdgeAttributeStoredConfig(id, name, item, config) {
     return mutateMeshEdgesEdgeStyle(id, {
       storedConfigs: {
-        [name]: config,
+        [name]: {
+          lastItem: item,
+          [item]: config,
+        },
       },
     });
   }
 
+  function applyEdgeAttribute(id) {
+    const name = meshEdgesEdgeAttributeName(id);
+    const item = meshEdgesEdgeAttributeItem(id);
+    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name, item);
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+    };
+    if (isMeshEdgesEdgeAttributeValid(attribute)) {
+      return setMeshEdgesEdgeAttribute(id, attribute);
+    }
+  }
+
   function meshEdgesEdgeAttributeName(id) {
     return meshEdgesEdgeAttribute(id).name;
   }
 
   function setMeshEdgesEdgeAttributeName(id, name) {
-    const schema = meshEdgesEdgeAttributeSchemas.name;
-    const params = { id, name };
-    return viewerStore.request(
-      {
-        schema,
-        params,
-      },
-      {
-        response_function: () => {
-          const updates = { name };
-          const edge = meshEdgesEdgeAttribute(id);
-          if (!(name in edge.storedConfigs)) {
-            updates.storedConfigs = {
-              [name]: {
-                minimum: undefined,
-                maximum: undefined,
-                colorMap: undefined,
-              },
-            };
-          }
-          return mutateMeshEdgesEdgeStyle(id, updates);
-        },
-      },
-    );
+    const item = meshEdgesEdgeAttributeLastItem(id, name);
+    mutateMeshEdgesEdgeStyle(id, { name, item });
+    return applyEdgeAttribute(id);
+  }
+
+  function meshEdgesEdgeAttributeItem(id) {
+    const { item, name } = meshEdgesEdgeAttribute(id);
+    return item ?? meshEdgesEdgeAttributeLastItem(id, name);
+  }
+
+  function setMeshEdgesEdgeAttributeItem(id, item) {
+    mutateMeshEdgesEdgeStyle(id, { item });
+    return applyEdgeAttribute(id);
+  }
+
+  function meshEdgesEdgeAttributeLastItem(id, name) {
+    const { storedConfigs } = meshEdgesEdgeAttribute(id);
+    if (storedConfigs && name in storedConfigs) {
+      return storedConfigs[name].lastItem;
+    }
+    return 0;
   }
 
   function meshEdgesEdgeAttributeRange(id) {
     const name = meshEdgesEdgeAttributeName(id);
-    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name);
-    const { minimum, maximum } = storedConfig;
-    return [minimum, maximum];
+    const item = meshEdgesEdgeAttributeItem(id);
+    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name, item);
+    return [storedConfig.minimum, storedConfig.maximum];
   }
 
   function setMeshEdgesEdgeAttributeRange(id, minimum, maximum) {
     const name = meshEdgesEdgeAttributeName(id);
-    const points = getRGBPointsFromPreset(meshEdgesEdgeAttributeColorMap(id));
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshEdgesEdgeAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        { schema, params },
-        {
-          response_function: () =>
-            setMeshEdgesEdgeAttributeStoredConfig(id, name, { minimum, maximum }),
-        },
-      );
-    }
-    return setMeshEdgesEdgeAttributeStoredConfig(id, name, {
-      minimum,
-      maximum,
-    });
+    const item = meshEdgesEdgeAttributeItem(id);
+    setMeshEdgesEdgeAttributeStoredConfig(id, name, item, { minimum, maximum });
+    return applyEdgeAttribute(id);
   }
 
   function meshEdgesEdgeAttributeColorMap(id) {
     const name = meshEdgesEdgeAttributeName(id);
-    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
+    const item = meshEdgesEdgeAttributeItem(id);
+    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name, item);
+    return storedConfig.colorMap;
   }
 
   function setMeshEdgesEdgeAttributeColorMap(id, colorMap) {
     const name = meshEdgesEdgeAttributeName(id);
-    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name);
+    const item = meshEdgesEdgeAttributeItem(id);
+    setMeshEdgesEdgeAttributeStoredConfig(id, name, item, { colorMap });
+    return applyEdgeAttribute(id);
+  }
+
+  function setMeshEdgesEdgeAttribute(id, { name, item, minimum, maximum, colorMap }) {
+    mutateMeshEdgesEdgeStyle(id, { name, item });
+    setMeshEdgesEdgeAttributeStoredConfig(id, name, item, { minimum, maximum, colorMap });
     const points = getRGBPointsFromPreset(colorMap);
-    const { minimum, maximum } = storedConfig;
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshEdgesEdgeAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        { schema, params },
-        {
-          response_function: () => setMeshEdgesEdgeAttributeStoredConfig(id, name, { colorMap }),
-        },
-      );
-    }
-    return setMeshEdgesEdgeAttributeStoredConfig(id, name, { colorMap });
+    const schema = meshEdgesEdgeAttributeSchemas.attribute;
+    const params = { id, name, item, points, minimum, maximum };
+    return viewerStore.request({ schema, params });
   }
 
   return {
     meshEdgesEdgeAttributeName,
+    meshEdgesEdgeAttributeItem,
     meshEdgesEdgeAttributeRange,
     meshEdgesEdgeAttributeColorMap,
     meshEdgesEdgeAttributeStoredConfig,
+    setMeshEdgesEdgeAttribute,
     setMeshEdgesEdgeAttributeName,
+    setMeshEdgesEdgeAttributeItem,
     setMeshEdgesEdgeAttributeRange,
     setMeshEdgesEdgeAttributeColorMap,
   };
 }
+
+export { isMeshEdgesEdgeAttributeValid, useMeshEdgesEdgeAttributeStyle };

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

@@ -1,10 +1,10 @@
 // Third party imports
 
 // Local imports
+import { isMeshEdgesEdgeAttributeValid, useMeshEdgesEdgeAttributeStyle } from "./edge";
+import { isMeshEdgesVertexAttributeValid, useMeshEdgesVertexAttributeStyle } from "./vertex";
 import { useMeshEdgesColorStyle } from "./color";
 import { useMeshEdgesCommonStyle } from "./common";
-import { useMeshEdgesEdgeAttributeStyle } from "./edge";
-import { useMeshEdgesVertexAttributeStyle } from "./vertex";
 import { useMeshEdgesVisibilityStyle } from "./visibility";
 import { useMeshEdgesWidthStyle } from "./width";
 
@@ -13,15 +13,15 @@ import { useMeshEdgesWidthStyle } from "./width";
 export function useMeshEdgesStyle() {
   const meshEdgesVisibility = useMeshEdgesVisibilityStyle();
   const meshEdgesColorStyle = useMeshEdgesColorStyle();
-
-  function meshEdgesColoring(id) {
-    return meshEdgesCommonStyle.meshEdgesColoring(id);
-  }
   const meshEdgesWidthStyle = useMeshEdgesWidthStyle();
   const meshEdgesVertexAttributeStyle = useMeshEdgesVertexAttributeStyle();
   const meshEdgesEdgeAttributeStyle = useMeshEdgesEdgeAttributeStyle();
   const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
 
+  function meshEdgesColoring(id) {
+    return meshEdgesCommonStyle.meshEdgesColoring(id);
+  }
+
   function meshEdgesActiveColoring(id) {
     return meshEdgesColoring(id).active;
   }
@@ -35,22 +35,25 @@ export function useMeshEdgesStyle() {
     }
     if (type === "vertex") {
       const name = meshEdgesVertexAttributeStyle.meshEdgesVertexAttributeName(id);
-      const { colorMap } = meshEdgesVertexAttributeStyle.meshEdgesVertexAttributeStoredConfig(
-        id,
-        name,
-      );
-      return Promise.all([
-        meshEdgesVertexAttributeStyle.setMeshEdgesVertexAttributeName(id, name),
-        meshEdgesVertexAttributeStyle.setMeshEdgesVertexAttributeColorMap(id, colorMap),
-      ]);
+      const item = meshEdgesVertexAttributeStyle.meshEdgesVertexAttributeItem(id);
+      const [minimum, maximum] = meshEdgesVertexAttributeStyle.meshEdgesVertexAttributeRange(id);
+      const colorMap = meshEdgesVertexAttributeStyle.meshEdgesVertexAttributeColorMap(id);
+      const vertex_attribute = { name, item, minimum, maximum, colorMap };
+      if (!isMeshEdgesVertexAttributeValid(vertex_attribute)) {
+        return;
+      }
+      return meshEdgesVertexAttributeStyle.setMeshEdgesVertexAttribute(id, vertex_attribute);
     }
     if (type === "edge") {
       const name = meshEdgesEdgeAttributeStyle.meshEdgesEdgeAttributeName(id);
-      const { colorMap } = meshEdgesEdgeAttributeStyle.meshEdgesEdgeAttributeStoredConfig(id, name);
-      return Promise.all([
-        meshEdgesEdgeAttributeStyle.setMeshEdgesEdgeAttributeName(id, name),
-        meshEdgesEdgeAttributeStyle.setMeshEdgesEdgeAttributeColorMap(id, colorMap),
-      ]);
+      const item = meshEdgesEdgeAttributeStyle.meshEdgesEdgeAttributeItem(id);
+      const [minimum, maximum] = meshEdgesEdgeAttributeStyle.meshEdgesEdgeAttributeRange(id);
+      const colorMap = meshEdgesEdgeAttributeStyle.meshEdgesEdgeAttributeColorMap(id);
+      const edge_attribute = { name, item, minimum, maximum, colorMap };
+      if (!isMeshEdgesEdgeAttributeValid(edge_attribute)) {
+        return;
+      }
+      return meshEdgesEdgeAttributeStyle.setMeshEdgesEdgeAttribute(id, edge_attribute);
     }
     throw new Error(`Unknown mesh edges coloring type: ${type}`);
   }

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

@@ -10,8 +10,18 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 const meshEdgesVertexAttributeSchemas =
   viewer_schemas.opengeodeweb_viewer.mesh.edges.attribute.vertex;
 
+function isMeshEdgesVertexAttributeValid({ 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 useMeshEdgesVertexAttributeStyle() {
+function useMeshEdgesVertexAttributeStyle() {
   const viewerStore = useViewerStore();
   const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
 
@@ -23,16 +33,16 @@ export function useMeshEdgesVertexAttributeStyle() {
     return meshEdgesColoring(id).vertex;
   }
 
-  function meshEdgesVertexAttributeStoredConfig(id, name) {
+  function meshEdgesVertexAttributeStoredConfig(id, name, item) {
     const { storedConfigs } = meshEdgesVertexAttribute(id);
-    if (name in storedConfigs) {
-      return storedConfigs[name];
+    if (storedConfigs && name in storedConfigs && item in storedConfigs[name]) {
+      return storedConfigs[name][item];
     }
-    return setMeshEdgesVertexAttributeStoredConfig(id, name, {
+    return {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    });
+    };
   }
 
   function mutateMeshEdgesVertexStyle(id, values) {
@@ -43,98 +53,110 @@ export function useMeshEdgesVertexAttributeStyle() {
     });
   }
 
-  function setMeshEdgesVertexAttributeStoredConfig(id, name, config) {
+  function setMeshEdgesVertexAttributeStoredConfig(id, name, item, config) {
     return mutateMeshEdgesVertexStyle(id, {
       storedConfigs: {
-        [name]: config,
+        [name]: {
+          lastItem: item,
+          [item]: config,
+        },
       },
-    }).then(() => config);
+    });
+  }
+
+  function applyVertexAttribute(id) {
+    const name = meshEdgesVertexAttributeName(id);
+    const item = meshEdgesVertexAttributeItem(id);
+    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name, item);
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+    };
+    if (isMeshEdgesVertexAttributeValid(attribute)) {
+      return setMeshEdgesVertexAttribute(id, attribute);
+    }
   }
 
   function meshEdgesVertexAttributeName(id) {
     return meshEdgesVertexAttribute(id).name;
   }
+
   function setMeshEdgesVertexAttributeName(id, name) {
-    const schema = meshEdgesVertexAttributeSchemas.name;
-    const params = { id, name };
-    return viewerStore.request(
-      { schema, params },
-      {
-        response_function: () => {
-          const updates = { name };
-          const vertex = meshEdgesVertexAttribute(id);
-          if (!(name in vertex.storedConfigs)) {
-            updates.storedConfigs = {
-              [name]: {
-                minimum: undefined,
-                maximum: undefined,
-                colorMap: undefined,
-              },
-            };
-          }
-          return mutateMeshEdgesVertexStyle(id, updates);
-        },
-      },
-    );
+    const item = meshEdgesVertexAttributeLastItem(id, name);
+    mutateMeshEdgesVertexStyle(id, { name, item });
+    return applyVertexAttribute(id);
+  }
+
+  function meshEdgesVertexAttributeItem(id) {
+    const { item, name } = meshEdgesVertexAttribute(id);
+    return item ?? meshEdgesVertexAttributeLastItem(id, name);
+  }
+
+  function setMeshEdgesVertexAttributeItem(id, item) {
+    mutateMeshEdgesVertexStyle(id, { item });
+    return applyVertexAttribute(id);
+  }
+
+  function meshEdgesVertexAttributeLastItem(id, name) {
+    const { storedConfigs } = meshEdgesVertexAttribute(id);
+    if (storedConfigs && name in storedConfigs) {
+      return storedConfigs[name].lastItem;
+    }
+    return 0;
   }
 
   function meshEdgesVertexAttributeRange(id) {
     const name = meshEdgesVertexAttributeName(id);
-    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name);
-    const { minimum, maximum } = storedConfig;
-    return [minimum, maximum];
+    const item = meshEdgesVertexAttributeItem(id);
+    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name, item);
+    return [storedConfig.minimum, storedConfig.maximum];
   }
+
   function setMeshEdgesVertexAttributeRange(id, minimum, maximum) {
     const name = meshEdgesVertexAttributeName(id);
-    const points = getRGBPointsFromPreset(meshEdgesVertexAttributeColorMap(id));
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshEdgesVertexAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        { schema, params },
-        {
-          response_function: () =>
-            setMeshEdgesVertexAttributeStoredConfig(id, name, { minimum, maximum }),
-        },
-      );
-    }
-    return setMeshEdgesVertexAttributeStoredConfig(id, name, {
-      minimum,
-      maximum,
-    });
+    const item = meshEdgesVertexAttributeItem(id);
+    setMeshEdgesVertexAttributeStoredConfig(id, name, item, { minimum, maximum });
+    return applyVertexAttribute(id);
   }
 
   function meshEdgesVertexAttributeColorMap(id) {
     const name = meshEdgesVertexAttributeName(id);
-    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
+    const item = meshEdgesVertexAttributeItem(id);
+    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name, item);
+    return storedConfig.colorMap;
   }
+
   function setMeshEdgesVertexAttributeColorMap(id, colorMap) {
     const name = meshEdgesVertexAttributeName(id);
-    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name);
+    const item = meshEdgesVertexAttributeItem(id);
+    setMeshEdgesVertexAttributeStoredConfig(id, name, item, { colorMap });
+    return applyVertexAttribute(id);
+  }
+
+  function setMeshEdgesVertexAttribute(id, { name, item, minimum, maximum, colorMap }) {
+    mutateMeshEdgesVertexStyle(id, { name, item });
+    setMeshEdgesVertexAttributeStoredConfig(id, name, item, { minimum, maximum, colorMap });
     const points = getRGBPointsFromPreset(colorMap);
-    const { minimum, maximum } = storedConfig;
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshEdgesVertexAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        { schema, params },
-        {
-          response_function: () => setMeshEdgesVertexAttributeStoredConfig(id, name, { colorMap }),
-        },
-      );
-    }
-    return setMeshEdgesVertexAttributeStoredConfig(id, name, { colorMap });
+    const schema = meshEdgesVertexAttributeSchemas.attribute;
+    const params = { id, name, item, points, minimum, maximum };
+    return viewerStore.request({ schema, params });
   }
 
   return {
     meshEdgesVertexAttributeName,
+    meshEdgesVertexAttributeItem,
     meshEdgesVertexAttributeRange,
     meshEdgesVertexAttributeColorMap,
     meshEdgesVertexAttributeStoredConfig,
+    setMeshEdgesVertexAttribute,
     setMeshEdgesVertexAttributeName,
+    setMeshEdgesVertexAttributeItem,
     setMeshEdgesVertexAttributeRange,
     setMeshEdgesVertexAttributeColorMap,
   };
 }
+
+export { isMeshEdgesVertexAttributeValid, useMeshEdgesVertexAttributeStyle };

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

@@ -1,10 +1,10 @@
 // Third party imports
 
 // Local imports
+import { isMeshPointsVertexAttributeValid, useMeshPointsVertexAttributeStyle } from "./vertex";
 import { useMeshPointsColorStyle } from "./color";
 import { useMeshPointsCommonStyle } from "./common";
 import { useMeshPointsSizeStyle } from "./size";
-import { useMeshPointsVertexAttributeStyle } from "./vertex";
 import { useMeshPointsVisibilityStyle } from "./visibility";
 
 // Local constants
@@ -31,14 +31,14 @@ function useMeshPointsColoringStyle() {
     }
     if (type === "vertex") {
       const name = meshPointsVertexAttributeStyle.meshPointsVertexAttributeName(id);
-      const { colorMap } = meshPointsVertexAttributeStyle.meshPointsVertexAttributeStoredConfig(
-        id,
-        name,
-      );
-      return Promise.all([
-        meshPointsVertexAttributeStyle.setMeshPointsVertexAttributeName(id, name),
-        meshPointsVertexAttributeStyle.setMeshPointsVertexAttributeColorMap(id, colorMap),
-      ]);
+      const item = meshPointsVertexAttributeStyle.meshPointsVertexAttributeItem(id);
+      const [minimum, maximum] = meshPointsVertexAttributeStyle.meshPointsVertexAttributeRange(id);
+      const colorMap = meshPointsVertexAttributeStyle.meshPointsVertexAttributeColorMap(id);
+      const vertex_attribute = { name, item, minimum, maximum, colorMap };
+      if (!isMeshPointsVertexAttributeValid(vertex_attribute)) {
+        return;
+      }
+      return meshPointsVertexAttributeStyle.setMeshPointsVertexAttribute(id, vertex_attribute);
     }
     throw new Error(`Unknown mesh points coloring type: ${type}`);
   }