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

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

@@ -10,25 +10,39 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 const meshPolygonsVertexAttributeSchemas =
   viewer_schemas.opengeodeweb_viewer.mesh.polygons.attribute.vertex;
 
+function isMeshPolygonsVertexAttributeValid({ 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 useMeshPolygonsVertexAttributeStyle() {
+function useMeshPolygonsVertexAttributeStyle() {
   const viewerStore = useViewerStore();
   const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle();
 
+  function meshPolygonsColoring(id) {
+    return meshPolygonsCommonStyle.meshPolygonsStyle(id).coloring;
+  }
+
   function meshPolygonsVertexAttribute(id) {
-    return meshPolygonsCommonStyle.meshPolygonsColoring(id).vertex;
+    return meshPolygonsColoring(id).vertex;
   }
 
-  function meshPolygonsVertexAttributeStoredConfig(id, name) {
+  function meshPolygonsVertexAttributeStoredConfig(id, name, item) {
     const { storedConfigs } = meshPolygonsVertexAttribute(id);
-    if (name in storedConfigs) {
-      return storedConfigs[name];
+    if (storedConfigs && name in storedConfigs && item in storedConfigs[name]) {
+      return storedConfigs[name][item];
     }
-    return setMeshPolygonsVertexAttributeStoredConfig(id, name, {
+    return {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    });
+    };
   }
 
   function mutateMeshPolygonsVertexStyle(id, values) {
@@ -39,102 +53,110 @@ export function useMeshPolygonsVertexAttributeStyle() {
     });
   }
 
-  function setMeshPolygonsVertexAttributeStoredConfig(id, name, config) {
+  function setMeshPolygonsVertexAttributeStoredConfig(id, name, item, config) {
     return mutateMeshPolygonsVertexStyle(id, {
       storedConfigs: {
-        [name]: config,
+        [name]: {
+          lastItem: item,
+          [item]: config,
+        },
       },
     });
   }
 
+  function applyVertexAttribute(id) {
+    const name = meshPolygonsVertexAttributeName(id);
+    const item = meshPolygonsVertexAttributeItem(id);
+    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name, item);
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+    };
+    if (isMeshPolygonsVertexAttributeValid(attribute)) {
+      return setMeshPolygonsVertexAttribute(id, attribute);
+    }
+  }
+
   function meshPolygonsVertexAttributeName(id) {
     return meshPolygonsVertexAttribute(id).name;
   }
 
   function setMeshPolygonsVertexAttributeName(id, name) {
-    const schema = meshPolygonsVertexAttributeSchemas.name;
-    const params = { id, name };
-    return viewerStore.request(
-      { schema, params },
-      {
-        response_function: () => {
-          const updates = { name };
-          const vertex = meshPolygonsVertexAttribute(id);
-          if (!(name in vertex.storedConfigs)) {
-            updates.storedConfigs = {
-              [name]: {
-                minimum: undefined,
-                maximum: undefined,
-                colorMap: undefined,
-              },
-            };
-          }
-          return mutateMeshPolygonsVertexStyle(id, updates);
-        },
-      },
-    );
+    const item = meshPolygonsVertexAttributeLastItem(id, name);
+    mutateMeshPolygonsVertexStyle(id, { name, item });
+    return applyVertexAttribute(id);
+  }
+
+  function meshPolygonsVertexAttributeItem(id) {
+    const { item, name } = meshPolygonsVertexAttribute(id);
+    return item ?? meshPolygonsVertexAttributeLastItem(id, name);
+  }
+
+  function setMeshPolygonsVertexAttributeItem(id, item) {
+    mutateMeshPolygonsVertexStyle(id, { item });
+    return applyVertexAttribute(id);
+  }
+
+  function meshPolygonsVertexAttributeLastItem(id, name) {
+    const { storedConfigs } = meshPolygonsVertexAttribute(id);
+    if (storedConfigs && name in storedConfigs) {
+      return storedConfigs[name].lastItem;
+    }
+    return 0;
   }
 
   function meshPolygonsVertexAttributeRange(id) {
     const name = meshPolygonsVertexAttributeName(id);
-    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name);
-    const { minimum, maximum } = storedConfig;
-    return [minimum, maximum];
+    const item = meshPolygonsVertexAttributeItem(id);
+    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name, item);
+    return [storedConfig.minimum, storedConfig.maximum];
   }
 
   function setMeshPolygonsVertexAttributeRange(id, minimum, maximum) {
     const name = meshPolygonsVertexAttributeName(id);
-    const points = getRGBPointsFromPreset(meshPolygonsVertexAttributeColorMap(id));
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshPolygonsVertexAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        { schema, params },
-        {
-          response_function: () =>
-            setMeshPolygonsVertexAttributeStoredConfig(id, name, { minimum, maximum }),
-        },
-      );
-    }
-    return setMeshPolygonsVertexAttributeStoredConfig(id, name, {
-      minimum,
-      maximum,
-    });
+    const item = meshPolygonsVertexAttributeItem(id);
+    setMeshPolygonsVertexAttributeStoredConfig(id, name, item, { minimum, maximum });
+    return applyVertexAttribute(id);
   }
 
   function meshPolygonsVertexAttributeColorMap(id) {
     const name = meshPolygonsVertexAttributeName(id);
-    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
+    const item = meshPolygonsVertexAttributeItem(id);
+    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name, item);
+    return storedConfig.colorMap;
   }
 
   function setMeshPolygonsVertexAttributeColorMap(id, colorMap) {
     const name = meshPolygonsVertexAttributeName(id);
-    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name);
+    const item = meshPolygonsVertexAttributeItem(id);
+    setMeshPolygonsVertexAttributeStoredConfig(id, name, item, { colorMap });
+    return applyVertexAttribute(id);
+  }
+
+  function setMeshPolygonsVertexAttribute(id, { name, item, minimum, maximum, colorMap }) {
+    mutateMeshPolygonsVertexStyle(id, { name, item });
+    setMeshPolygonsVertexAttributeStoredConfig(id, name, item, { minimum, maximum, colorMap });
     const points = getRGBPointsFromPreset(colorMap);
-    const { minimum, maximum } = storedConfig;
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshPolygonsVertexAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        { schema, params },
-        {
-          response_function: () =>
-            setMeshPolygonsVertexAttributeStoredConfig(id, name, { colorMap }),
-        },
-      );
-    }
-    return setMeshPolygonsVertexAttributeStoredConfig(id, name, { colorMap });
+    const schema = meshPolygonsVertexAttributeSchemas.attribute;
+    const params = { id, name, item, points, minimum, maximum };
+    return viewerStore.request({ schema, params });
   }
 
   return {
     meshPolygonsVertexAttributeName,
+    meshPolygonsVertexAttributeItem,
     meshPolygonsVertexAttributeRange,
     meshPolygonsVertexAttributeColorMap,
     meshPolygonsVertexAttributeStoredConfig,
+    setMeshPolygonsVertexAttribute,
     setMeshPolygonsVertexAttributeName,
+    setMeshPolygonsVertexAttributeItem,
     setMeshPolygonsVertexAttributeRange,
     setMeshPolygonsVertexAttributeColorMap,
   };
 }
+
+export { isMeshPolygonsVertexAttributeValid, useMeshPolygonsVertexAttributeStyle };

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

@@ -1,11 +1,16 @@
 // Third party imports
 
 // Local imports
-
+import {
+  isMeshPolyhedraPolyhedronAttributeValid,
+  useMeshPolyhedraPolyhedronAttributeStyle,
+} from "./polyhedron";
+import {
+  isMeshPolyhedraVertexAttributeValid,
+  useMeshPolyhedraVertexAttributeStyle,
+} from "./vertex";
 import { useMeshPolyhedraColorStyle } from "./color";
 import { useMeshPolyhedraCommonStyle } from "./common";
-import { useMeshPolyhedraPolyhedronAttributeStyle } from "./polyhedron";
-import { useMeshPolyhedraVertexAttributeStyle } from "./vertex";
 import { useMeshPolyhedraVisibilityStyle } from "./visibility";
 
 // Local constants
@@ -29,7 +34,6 @@ export function useMeshPolyhedraStyle() {
     await meshPolyhedraCommonStyle.mutateMeshPolyhedraStyle(id, {
       coloring: { active: type },
     });
-    console.log(setMeshPolyhedraActiveColoring.name, { id }, type);
     if (type === "constant") {
       return meshPolyhedraColorStyle.setMeshPolyhedraColor(
         id,
@@ -38,27 +42,34 @@ export function useMeshPolyhedraStyle() {
     }
     if (type === "vertex") {
       const name = meshPolyhedraVertexAttributeStyle.meshPolyhedraVertexAttributeName(id);
-      const { colorMap } =
-        meshPolyhedraVertexAttributeStyle.meshPolyhedraVertexAttributeStoredConfig(id, name);
-      return Promise.all([
-        meshPolyhedraVertexAttributeStyle.setMeshPolyhedraVertexAttributeName(id, name),
-        meshPolyhedraVertexAttributeStyle.setMeshPolyhedraVertexAttributeColorMap(id, colorMap),
-      ]);
+      const item = meshPolyhedraVertexAttributeStyle.meshPolyhedraVertexAttributeItem(id);
+      const [minimum, maximum] =
+        meshPolyhedraVertexAttributeStyle.meshPolyhedraVertexAttributeRange(id);
+      const colorMap = meshPolyhedraVertexAttributeStyle.meshPolyhedraVertexAttributeColorMap(id);
+      const vertex_attribute = { name, item, minimum, maximum, colorMap };
+      if (!isMeshPolyhedraVertexAttributeValid(vertex_attribute)) {
+        return;
+      }
+      return meshPolyhedraVertexAttributeStyle.setMeshPolyhedraVertexAttribute(
+        id,
+        vertex_attribute,
+      );
     }
     if (type === "polyhedron") {
       const name = meshPolyhedraPolyhedronAttributeStyle.meshPolyhedraPolyhedronAttributeName(id);
-      const { colorMap } =
-        meshPolyhedraPolyhedronAttributeStyle.meshPolyhedraPolyhedronAttributeStoredConfig(
-          id,
-          name,
-        );
-      return Promise.all([
-        meshPolyhedraPolyhedronAttributeStyle.setMeshPolyhedraPolyhedronAttributeName(id, name),
-        meshPolyhedraPolyhedronAttributeStyle.setMeshPolyhedraPolyhedronAttributeColorMap(
-          id,
-          colorMap,
-        ),
-      ]);
+      const item = meshPolyhedraPolyhedronAttributeStyle.meshPolyhedraPolyhedronAttributeItem(id);
+      const [minimum, maximum] =
+        meshPolyhedraPolyhedronAttributeStyle.meshPolyhedraPolyhedronAttributeRange(id);
+      const colorMap =
+        meshPolyhedraPolyhedronAttributeStyle.meshPolyhedraPolyhedronAttributeColorMap(id);
+      const polyhedron_attribute = { name, item, minimum, maximum, colorMap };
+      if (!isMeshPolyhedraPolyhedronAttributeValid(polyhedron_attribute)) {
+        return;
+      }
+      return meshPolyhedraPolyhedronAttributeStyle.setMeshPolyhedraPolyhedronAttribute(
+        id,
+        polyhedron_attribute,
+      );
     }
     throw new Error(`Unknown mesh polyhedra coloring type: ${type}`);
   }

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

@@ -10,12 +10,39 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 const meshPolyhedraPolyhedronAttributeSchemas =
   viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.attribute.polyhedron;
 
+function isMeshPolyhedraPolyhedronAttributeValid({ 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 useMeshPolyhedraPolyhedronAttributeConfig() {
+function useMeshPolyhedraPolyhedronAttributeStyle() {
+  const viewerStore = useViewerStore();
   const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle();
 
+  function meshPolyhedraColoring(id) {
+    return meshPolyhedraCommonStyle.meshPolyhedraStyle(id).coloring;
+  }
+
   function meshPolyhedraPolyhedronAttribute(id) {
-    return meshPolyhedraCommonStyle.meshPolyhedraColoring(id).polyhedron;
+    return meshPolyhedraColoring(id).polyhedron;
+  }
+
+  function meshPolyhedraPolyhedronAttributeStoredConfig(id, name, item) {
+    const { storedConfigs } = meshPolyhedraPolyhedronAttribute(id);
+    if (storedConfigs && name in storedConfigs && item in storedConfigs[name]) {
+      return storedConfigs[name][item];
+    }
+    return {
+      minimum: undefined,
+      maximum: undefined,
+      colorMap: undefined,
+    };
   }
 
   function mutateMeshPolyhedraPolyhedronStyle(id, values) {
@@ -26,139 +53,110 @@ function useMeshPolyhedraPolyhedronAttributeConfig() {
     });
   }
 
-  function setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, config) {
+  function setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, item, config) {
     return mutateMeshPolyhedraPolyhedronStyle(id, {
       storedConfigs: {
-        [name]: config,
+        [name]: {
+          lastItem: item,
+          [item]: config,
+        },
       },
     });
   }
 
-  function meshPolyhedraPolyhedronAttributeStoredConfig(id, name) {
-    const { storedConfigs } = meshPolyhedraPolyhedronAttribute(id);
-    if (name in storedConfigs) {
-      return storedConfigs[name];
+  function applyPolyhedronAttribute(id) {
+    const name = meshPolyhedraPolyhedronAttributeName(id);
+    const item = meshPolyhedraPolyhedronAttributeItem(id);
+    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name, item);
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+    };
+    if (isMeshPolyhedraPolyhedronAttributeValid(attribute)) {
+      return setMeshPolyhedraPolyhedronAttribute(id, attribute);
     }
-    return setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, {
-      minimum: undefined,
-      maximum: undefined,
-      colorMap: undefined,
-    });
   }
 
   function meshPolyhedraPolyhedronAttributeName(id) {
     return meshPolyhedraPolyhedronAttribute(id).name;
   }
 
-  function meshPolyhedraPolyhedronAttributeRange(id) {
-    const name = meshPolyhedraPolyhedronAttributeName(id);
-    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name);
-    const { minimum, maximum } = storedConfig;
-    return [minimum, maximum];
+  function setMeshPolyhedraPolyhedronAttributeName(id, name) {
+    const item = meshPolyhedraPolyhedronAttributeLastItem(id, name);
+    mutateMeshPolyhedraPolyhedronStyle(id, { name, item });
+    return applyPolyhedronAttribute(id);
   }
 
-  function meshPolyhedraPolyhedronAttributeColorMap(id) {
-    const name = meshPolyhedraPolyhedronAttributeName(id);
-    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
+  function meshPolyhedraPolyhedronAttributeItem(id) {
+    const { item, name } = meshPolyhedraPolyhedronAttribute(id);
+    return item ?? meshPolyhedraPolyhedronAttributeLastItem(id, name);
   }
 
-  return {
-    meshPolyhedraPolyhedronAttribute,
-    meshPolyhedraPolyhedronAttributeStoredConfig,
-    setMeshPolyhedraPolyhedronAttributeStoredConfig,
-    mutateMeshPolyhedraPolyhedronStyle,
-    meshPolyhedraPolyhedronAttributeName,
-    meshPolyhedraPolyhedronAttributeRange,
-    meshPolyhedraPolyhedronAttributeColorMap,
-  };
-}
+  function setMeshPolyhedraPolyhedronAttributeItem(id, item) {
+    mutateMeshPolyhedraPolyhedronStyle(id, { item });
+    return applyPolyhedronAttribute(id);
+  }
 
-// oxlint-disable-next-line max-lines-per-function
-function useMeshPolyhedraPolyhedronAttributeActions() {
-  const viewerStore = useViewerStore();
-  const config = useMeshPolyhedraPolyhedronAttributeConfig();
+  function meshPolyhedraPolyhedronAttributeLastItem(id, name) {
+    const { storedConfigs } = meshPolyhedraPolyhedronAttribute(id);
+    if (storedConfigs && name in storedConfigs) {
+      return storedConfigs[name].lastItem;
+    }
+    return 0;
+  }
 
-  function setMeshPolyhedraPolyhedronAttributeName(id, name) {
-    const schema = meshPolyhedraPolyhedronAttributeSchemas.name;
-    const params = { id, name };
-    return viewerStore.request(
-      {
-        schema,
-        params,
-      },
-      {
-        response_function: () => {
-          const updates = { name };
-          const polyhedron = config.meshPolyhedraPolyhedronAttribute(id);
-          if (!(name in polyhedron.storedConfigs)) {
-            updates.storedConfigs = {
-              [name]: {
-                minimum: undefined,
-                maximum: undefined,
-                colorMap: undefined,
-              },
-            };
-          }
-          return config.mutateMeshPolyhedraPolyhedronStyle(id, updates);
-        },
-      },
-    );
+  function meshPolyhedraPolyhedronAttributeRange(id) {
+    const name = meshPolyhedraPolyhedronAttributeName(id);
+    const item = meshPolyhedraPolyhedronAttributeItem(id);
+    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name, item);
+    return [storedConfig.minimum, storedConfig.maximum];
   }
 
   function setMeshPolyhedraPolyhedronAttributeRange(id, minimum, maximum) {
-    const name = config.meshPolyhedraPolyhedronAttributeName(id);
-    const points = getRGBPointsFromPreset(config.meshPolyhedraPolyhedronAttributeColorMap(id));
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshPolyhedraPolyhedronAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        { schema, params },
-        {
-          response_function: () =>
-            config.setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, { minimum, maximum }),
-        },
-      );
-    }
-    return config.setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, {
-      minimum,
-      maximum,
-    });
+    const name = meshPolyhedraPolyhedronAttributeName(id);
+    const item = meshPolyhedraPolyhedronAttributeItem(id);
+    setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, item, { minimum, maximum });
+    return applyPolyhedronAttribute(id);
+  }
+
+  function meshPolyhedraPolyhedronAttributeColorMap(id) {
+    const name = meshPolyhedraPolyhedronAttributeName(id);
+    const item = meshPolyhedraPolyhedronAttributeItem(id);
+    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name, item);
+    return storedConfig.colorMap;
   }
 
   function setMeshPolyhedraPolyhedronAttributeColorMap(id, colorMap) {
-    const name = config.meshPolyhedraPolyhedronAttributeName(id);
-    const storedConfig = config.meshPolyhedraPolyhedronAttributeStoredConfig(id, name);
+    const name = meshPolyhedraPolyhedronAttributeName(id);
+    const item = meshPolyhedraPolyhedronAttributeItem(id);
+    setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, item, { colorMap });
+    return applyPolyhedronAttribute(id);
+  }
+
+  function setMeshPolyhedraPolyhedronAttribute(id, { name, item, minimum, maximum, colorMap }) {
+    mutateMeshPolyhedraPolyhedronStyle(id, { name, item });
+    setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, item, { minimum, maximum, colorMap });
     const points = getRGBPointsFromPreset(colorMap);
-    const { minimum, maximum } = storedConfig;
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const schema = meshPolyhedraPolyhedronAttributeSchemas.color_map;
-      const params = { id, points, minimum, maximum };
-      return viewerStore.request(
-        { schema, params },
-        {
-          response_function: () =>
-            config.setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, { colorMap }),
-        },
-      );
-    }
-    return config.setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, { colorMap });
+    const schema = meshPolyhedraPolyhedronAttributeSchemas.attribute;
+    const params = { id, name, item, points, minimum, maximum };
+    return viewerStore.request({ schema, params });
   }
 
   return {
+    meshPolyhedraPolyhedronAttributeName,
+    meshPolyhedraPolyhedronAttributeItem,
+    meshPolyhedraPolyhedronAttributeRange,
+    meshPolyhedraPolyhedronAttributeColorMap,
+    meshPolyhedraPolyhedronAttributeStoredConfig,
+    setMeshPolyhedraPolyhedronAttribute,
     setMeshPolyhedraPolyhedronAttributeName,
+    setMeshPolyhedraPolyhedronAttributeItem,
     setMeshPolyhedraPolyhedronAttributeRange,
     setMeshPolyhedraPolyhedronAttributeColorMap,
   };
 }
 
-export function useMeshPolyhedraPolyhedronAttributeStyle() {
-  const config = useMeshPolyhedraPolyhedronAttributeConfig();
-  const actions = useMeshPolyhedraPolyhedronAttributeActions();
-
-  return {
-    ...config,
-    ...actions,
-  };
-}
+export { isMeshPolyhedraPolyhedronAttributeValid, useMeshPolyhedraPolyhedronAttributeStyle };