@geode/opengeodeweb-front 10.7.0 → 10.8.0-rc.2

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

@@ -30,31 +30,44 @@ export function useMeshCellsVertexAttributeStyle() {
     });
   }
 
-  function setMeshCellsVertexAttributeStoredConfig(id, name, { minimum, maximum, colorMap }) {
-    const { storedConfigs } = meshCellsVertexAttribute(id);
-    storedConfigs[name] = { minimum, maximum, colorMap };
-    return storedConfigs[name];
+  function mutateMeshCellsVertexStyle(id, values) {
+    return meshCellsCommonStyle.mutateMeshCellsStyle(id, {
+      coloring: {
+        vertex: values,
+      },
+    });
+  }
+
+  function setMeshCellsVertexAttributeStoredConfig(id, name, config) {
+    return mutateMeshCellsVertexStyle(id, {
+      storedConfigs: {
+        [name]: config,
+      },
+    });
   }
 
   function meshCellsVertexAttributeName(id) {
-    console.log(meshCellsVertexAttributeName.name, { id }, meshCellsVertexAttribute(id));
     return meshCellsVertexAttribute(id).name;
   }
+
   function setMeshCellsVertexAttributeName(id, name) {
-    console.log(setMeshCellsVertexAttributeName.name, { id, name });
     return viewerStore.request(
       meshCellsVertexAttributeSchemas.name,
       { id, name },
       {
-        response_function: async () => {
-          meshCellsVertexAttribute(id).name = name;
-          const { minimum, maximum } = meshCellsVertexAttributeStoredConfig(id, name);
-          await setMeshCellsVertexAttributeRange(id, minimum, maximum);
-          console.log(
-            setMeshCellsVertexAttributeName.name,
-            { id },
-            meshCellsVertexAttributeName(id),
-          );
+        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);
         },
       },
     );
@@ -66,12 +79,13 @@ export function useMeshCellsVertexAttributeStyle() {
     const { minimum, maximum } = storedConfig;
     return [minimum, maximum];
   }
+
   function setMeshCellsVertexAttributeRange(id, minimum, maximum) {
     const name = meshCellsVertexAttributeName(id);
-    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name);
-    storedConfig.minimum = minimum;
-    storedConfig.maximum = maximum;
-    return setMeshCellsVertexAttributeColorMap(id, storedConfig.colorMap);
+    return setMeshCellsVertexAttributeStoredConfig(id, name, {
+      minimum,
+      maximum,
+    });
   }
 
   function meshCellsVertexAttributeColorMap(id) {
@@ -80,38 +94,17 @@ export function useMeshCellsVertexAttributeStyle() {
     const { colorMap } = storedConfig;
     return colorMap;
   }
+
   function setMeshCellsVertexAttributeColorMap(id, colorMap) {
     const name = meshCellsVertexAttributeName(id);
     const storedConfig = meshCellsVertexAttributeStoredConfig(id, name);
-    if (
-      storedConfig.minimum === undefined ||
-      storedConfig.maximum === undefined ||
-      colorMap === undefined
-    ) {
-      storedConfig.colorMap = colorMap;
-      return;
-    }
     const points = getRGBPointsFromPreset(colorMap);
     const { minimum, maximum } = storedConfig;
-
-    console.log(setMeshCellsVertexAttributeColorMap.name, {
-      id,
-      minimum,
-      maximum,
-      colorMap,
-    });
     return viewerStore.request(
       meshCellsVertexAttributeSchemas.color_map,
       { id, points, minimum, maximum },
       {
-        response_function: () => {
-          storedConfig.colorMap = colorMap;
-          console.log(
-            setMeshCellsVertexAttributeColorMap.name,
-            { id },
-            meshCellsVertexAttributeColorMap(id),
-          );
-        },
+        response_function: () => setMeshCellsVertexAttributeStoredConfig(id, name, { colorMap }),
       },
     );
   }

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

@@ -20,10 +20,7 @@ export function useMeshCellsVisibilityStyle() {
       meshCellsVisibilitySchema,
       { id, visibility },
       {
-        response_function: () => {
-          meshCellsCommonStyle.meshCellsStyle(id).visibility = visibility;
-          console.log(setMeshCellsVisibility.name, { id }, meshCellsVisibility(id));
-        },
+        response_function: () => meshCellsCommonStyle.mutateMeshCellsStyle(id, { visibility }),
       },
     );
   }

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

@@ -20,10 +20,10 @@ export function useMeshEdgesColorStyle() {
       meshEdgesColorSchemas,
       { id, color },
       {
-        response_function: () => {
-          meshEdgesCommonStyle.meshEdgesColoring(id).color = color;
-          console.log(setMeshEdgesColor.name, { id }, JSON.stringify(meshEdgesColor(id)));
-        },
+        response_function: () =>
+          meshEdgesCommonStyle.mutateMeshEdgesColoring(id, {
+            color,
+          }),
       },
     );
   }

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

@@ -3,6 +3,12 @@ import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state";
 export function useMeshEdgesCommonStyle() {
   const dataStyleStateStore = useDataStyleStateStore();
 
+  function mutateMeshEdgesStyle(id, values) {
+    return dataStyleStateStore.mutateStyle(id, {
+      edges: values,
+    });
+  }
+
   function meshEdgesStyle(id) {
     return dataStyleStateStore.getStyle(id).edges;
   }
@@ -11,13 +17,16 @@ export function useMeshEdgesCommonStyle() {
     return meshEdgesStyle(id).coloring;
   }
 
-  function meshEdgesActiveColoring(id) {
-    return meshEdgesColoring(id).active;
+  function mutateMeshEdgesColoring(id, values) {
+    return mutateMeshEdgesStyle(id, {
+      coloring: values,
+    });
   }
 
   return {
     meshEdgesStyle,
     meshEdgesColoring,
-    meshEdgesActiveColoring,
+    mutateMeshEdgesStyle,
+    mutateMeshEdgesColoring,
   };
 }

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

@@ -2,7 +2,6 @@
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 // Local imports
-import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
 import { useMeshEdgesCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
@@ -13,8 +12,12 @@ export function useMeshEdgesEdgeAttributeStyle() {
   const viewerStore = useViewerStore();
   const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
 
+  function meshEdgesColoring(id) {
+    return meshEdgesCommonStyle.meshEdgesStyle(id).coloring;
+  }
+
   function meshEdgesEdgeAttribute(id) {
-    return meshEdgesCommonStyle.meshEdgesColoring(id).edge;
+    return meshEdgesColoring(id).edge;
   }
 
   function meshEdgesEdgeAttributeStoredConfig(id, name) {
@@ -29,27 +32,44 @@ export function useMeshEdgesEdgeAttributeStyle() {
     });
   }
 
-  function setMeshEdgesEdgeAttributeStoredConfig(id, name, { minimum, maximum, colorMap }) {
-    const { storedConfigs } = meshEdgesEdgeAttribute(id);
-    storedConfigs[name] = { minimum, maximum, colorMap };
-    return storedConfigs[name];
+  function mutateMeshEdgesEdgeStyle(id, values) {
+    return meshEdgesCommonStyle.mutateMeshEdgesStyle(id, {
+      coloring: {
+        edge: values,
+      },
+    });
+  }
+
+  function setMeshEdgesEdgeAttributeStoredConfig(id, name, config) {
+    return mutateMeshEdgesEdgeStyle(id, {
+      storedConfigs: {
+        [name]: config,
+      },
+    });
   }
 
   function meshEdgesEdgeAttributeName(id) {
-    console.log(meshEdgesEdgeAttributeName.name, { id }, meshEdgesEdgeAttribute(id));
     return meshEdgesEdgeAttribute(id).name;
   }
+
   function setMeshEdgesEdgeAttributeName(id, name) {
-    console.log(setMeshEdgesEdgeAttributeName.name, { id, name });
     return viewerStore.request(
       meshEdgesEdgeAttributeSchemas.name,
       { id, name },
       {
-        response_function: async () => {
-          meshEdgesEdgeAttribute(id).name = name;
-          const { minimum, maximum } = meshEdgesEdgeAttributeStoredConfig(id, name);
-          await setMeshEdgesEdgeAttributeRange(id, minimum, maximum);
-          console.log(setMeshEdgesEdgeAttributeName.name, { id }, meshEdgesEdgeAttributeName(id));
+        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);
         },
       },
     );
@@ -61,12 +81,13 @@ export function useMeshEdgesEdgeAttributeStyle() {
     const { minimum, maximum } = storedConfig;
     return [minimum, maximum];
   }
+
   function setMeshEdgesEdgeAttributeRange(id, minimum, maximum) {
     const name = meshEdgesEdgeAttributeName(id);
-    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name);
-    storedConfig.minimum = minimum;
-    storedConfig.maximum = maximum;
-    return setMeshEdgesEdgeAttributeColorMap(id, storedConfig.colorMap);
+    return setMeshEdgesEdgeAttributeStoredConfig(id, name, {
+      minimum,
+      maximum,
+    });
   }
 
   function meshEdgesEdgeAttributeColorMap(id) {
@@ -75,38 +96,17 @@ export function useMeshEdgesEdgeAttributeStyle() {
     const { colorMap } = storedConfig;
     return colorMap;
   }
+
   function setMeshEdgesEdgeAttributeColorMap(id, colorMap) {
     const name = meshEdgesEdgeAttributeName(id);
     const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name);
-    if (
-      storedConfig.minimum === undefined ||
-      storedConfig.maximum === undefined ||
-      colorMap === undefined
-    ) {
-      storedConfig.colorMap = colorMap;
-      return;
-    }
     const points = getRGBPointsFromPreset(colorMap);
     const { minimum, maximum } = storedConfig;
-
-    console.log(setMeshEdgesEdgeAttributeColorMap.name, {
-      id,
-      minimum,
-      maximum,
-      colorMap,
-    });
     return viewerStore.request(
       meshEdgesEdgeAttributeSchemas.color_map,
       { id, points, minimum, maximum },
       {
-        response_function: () => {
-          storedConfig.colorMap = colorMap;
-          console.log(
-            setMeshEdgesEdgeAttributeColorMap.name,
-            { id },
-            meshEdgesEdgeAttributeColorMap(id),
-          );
-        },
+        response_function: () => setMeshEdgesEdgeAttributeStoredConfig(id, name, { colorMap }),
       },
     );
   }

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

@@ -11,42 +11,39 @@ import { useMeshEdgesWidthStyle } from "./width";
 // Local constants
 
 export function useMeshEdgesStyle() {
-  const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
   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 setMeshEdgesActiveColoring(id, type) {
-    const coloring = meshEdgesCommonStyle.meshEdgesColoring(id);
-    coloring.active = type;
-    console.log(
-      setMeshEdgesActiveColoring.name,
-      { id },
-      meshEdgesCommonStyle.meshEdgesActiveColoring(id),
-    );
+  function meshEdgesActiveColoring(id) {
+    return meshEdgesColoring(id).active;
+  }
+
+  async function setMeshEdgesActiveColoring(id, type) {
+    await meshEdgesCommonStyle.mutateMeshEdgesStyle(id, {
+      coloring: { active: type },
+    });
     if (type === "color") {
       return meshEdgesColorStyle.setMeshEdgesColor(id, meshEdgesColorStyle.meshEdgesColor(id));
     }
-    if (type === "textures") {
-      const textures = meshEdgesTexturesStore.meshEdgesTextures(id);
-      if (textures === undefined) {
-        return Promise.resolve();
-      }
-      return meshEdgesTexturesStore.setMeshEdgesTextures(id, textures);
-    }
     if (type === "vertex") {
       const name = meshEdgesVertexAttributeStyle.meshEdgesVertexAttributeName(id);
       if (name === undefined) {
-        return Promise.resolve();
+        return;
       }
       return meshEdgesVertexAttributeStyle.setMeshEdgesVertexAttributeName(id, name);
     }
     if (type === "edge") {
       const name = meshEdgesEdgeAttributeStyle.meshEdgesEdgeAttributeName(id);
       if (name === undefined) {
-        return Promise.resolve();
+        return;
       }
       return meshEdgesEdgeAttributeStyle.setMeshEdgesEdgeAttributeName(id, name);
     }
@@ -57,11 +54,13 @@ export function useMeshEdgesStyle() {
     return Promise.all([
       meshEdgesVisibility.setMeshEdgesVisibility(id, meshEdgesVisibility.meshEdgesVisibility(id)),
       meshEdgesWidthStyle.setMeshEdgesWidth(id, meshEdgesWidthStyle.meshEdgesWidth(id)),
-      setMeshEdgesActiveColoring(id, meshEdgesCommonStyle.meshEdgesActiveColoring(id)),
+      setMeshEdgesActiveColoring(id, meshEdgesActiveColoring(id)),
     ]);
   }
 
   return {
+    meshEdgesColoring,
+    meshEdgesActiveColoring,
     setMeshEdgesActiveColoring,
     applyMeshEdgesStyle,
     ...meshEdgesCommonStyle,

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

@@ -2,7 +2,6 @@
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 // Local imports
-import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
 import { useMeshEdgesCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
@@ -14,8 +13,12 @@ export function useMeshEdgesVertexAttributeStyle() {
   const viewerStore = useViewerStore();
   const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
 
+  function meshEdgesColoring(id) {
+    return meshEdgesCommonStyle.meshEdgesStyle(id).coloring;
+  }
+
   function meshEdgesVertexAttribute(id) {
-    return meshEdgesCommonStyle.meshEdgesColoring(id).vertex;
+    return meshEdgesColoring(id).vertex;
   }
 
   function meshEdgesVertexAttributeStoredConfig(id, name) {
@@ -30,31 +33,43 @@ export function useMeshEdgesVertexAttributeStyle() {
     });
   }
 
-  function setMeshEdgesVertexAttributeStoredConfig(id, name, { minimum, maximum, colorMap }) {
-    const { storedConfigs } = meshEdgesVertexAttribute(id);
-    storedConfigs[name] = { minimum, maximum, colorMap };
-    return storedConfigs[name];
+  function mutateMeshEdgesVertexStyle(id, values) {
+    return meshEdgesCommonStyle.mutateMeshEdgesStyle(id, {
+      coloring: {
+        vertex: values,
+      },
+    });
+  }
+
+  function setMeshEdgesVertexAttributeStoredConfig(id, name, config) {
+    return mutateMeshEdgesVertexStyle(id, {
+      storedConfigs: {
+        [name]: config,
+      },
+    }).then(() => config);
   }
 
   function meshEdgesVertexAttributeName(id) {
-    console.log(meshEdgesVertexAttributeName.name, { id }, meshEdgesVertexAttribute(id));
     return meshEdgesVertexAttribute(id).name;
   }
   function setMeshEdgesVertexAttributeName(id, name) {
-    console.log(setMeshEdgesVertexAttributeName.name, { id, name });
     return viewerStore.request(
       meshEdgesVertexAttributeSchemas.name,
       { id, name },
       {
-        response_function: async () => {
-          meshEdgesVertexAttribute(id).name = name;
-          const { minimum, maximum } = meshEdgesVertexAttributeStoredConfig(id, name);
-          await setMeshEdgesVertexAttributeRange(id, minimum, maximum);
-          console.log(
-            setMeshEdgesVertexAttributeName.name,
-            { id },
-            meshEdgesVertexAttributeName(id),
-          );
+        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);
         },
       },
     );
@@ -68,10 +83,10 @@ export function useMeshEdgesVertexAttributeStyle() {
   }
   function setMeshEdgesVertexAttributeRange(id, minimum, maximum) {
     const name = meshEdgesVertexAttributeName(id);
-    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name);
-    storedConfig.minimum = minimum;
-    storedConfig.maximum = maximum;
-    return setMeshEdgesVertexAttributeColorMap(id, storedConfig.colorMap);
+    return setMeshEdgesVertexAttributeStoredConfig(id, name, {
+      minimum,
+      maximum,
+    });
   }
 
   function meshEdgesVertexAttributeColorMap(id) {
@@ -83,35 +98,13 @@ export function useMeshEdgesVertexAttributeStyle() {
   function setMeshEdgesVertexAttributeColorMap(id, colorMap) {
     const name = meshEdgesVertexAttributeName(id);
     const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name);
-    if (
-      storedConfig.minimum === undefined ||
-      storedConfig.maximum === undefined ||
-      colorMap === undefined
-    ) {
-      storedConfig.colorMap = colorMap;
-      return;
-    }
     const points = getRGBPointsFromPreset(colorMap);
     const { minimum, maximum } = storedConfig;
-
-    console.log(setMeshEdgesVertexAttributeColorMap.name, {
-      id,
-      minimum,
-      maximum,
-      colorMap,
-    });
     return viewerStore.request(
       meshEdgesVertexAttributeSchemas.color_map,
       { id, points, minimum, maximum },
       {
-        response_function: () => {
-          storedConfig.colorMap = colorMap;
-          console.log(
-            setMeshEdgesVertexAttributeColorMap.name,
-            { id },
-            meshEdgesVertexAttributeColorMap(id),
-          );
-        },
+        response_function: () => setMeshEdgesVertexAttributeStoredConfig(id, name, { colorMap }),
       },
     );
   }

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

@@ -1,7 +1,6 @@
 // Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
-// Local imports
 import { useMeshEdgesCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
@@ -20,10 +19,7 @@ export function useMeshEdgesVisibilityStyle() {
       meshEdgesVisibilitySchema,
       { id, visibility },
       {
-        response_function: () => {
-          meshEdgesCommonStyle.meshEdgesStyle(id).visibility = visibility;
-          console.log(setMeshEdgesVisibility.name, { id }, meshEdgesVisibility(id));
-        },
+        response_function: () => meshEdgesCommonStyle.mutateMeshEdgesStyle(id, { visibility }),
       },
     );
   }

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

@@ -1,7 +1,6 @@
 // Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
-// Local imports
 import { useMeshEdgesCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
@@ -20,10 +19,7 @@ export function useMeshEdgesWidthStyle() {
       meshEdgesWidthSchemas,
       { id, width },
       {
-        response_function: () => {
-          meshEdgesCommonStyle.meshEdgesStyle(id).width = width;
-          console.log(setMeshEdgesWidth.name, { id }, JSON.stringify(meshEdgesWidth(id)));
-        },
+        response_function: () => meshEdgesCommonStyle.mutateMeshEdgesStyle(id, { width }),
       },
     );
   }

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

@@ -33,21 +33,36 @@ export function useMeshStyle() {
       meshSchemas.visibility,
       { id, visibility },
       {
-        response_function: () => {
-          hybridViewerStore.setVisibility(id, visibility);
-          dataStyleState.getStyle(id).visibility = visibility;
-          console.log(setMeshVisibility.name, { id }, meshVisibility(id));
+        response_function: async () => {
+          await hybridViewerStore.setVisibility(id, visibility);
+          return dataStyleState.mutateStyle(id, { visibility });
         },
       },
     );
   }
 
+  function meshColor(id) {
+    return dataStyleState.getStyle(id).color;
+  }
+
+  function setMeshColor(id, color) {
+    return viewerStore.request(
+      meshSchemas.color,
+      { id, color },
+      {
+        response_function: () => dataStyleState.mutateStyle(id, { color }),
+      },
+    );
+  }
+
   function applyMeshStyle(id) {
     const style = dataStyleState.getStyle(id);
     const promise_array = [];
     for (const [key, value] of Object.entries(style)) {
       if (key === "visibility") {
         promise_array.push(setMeshVisibility(id, value));
+      } else if (key === "color") {
+        promise_array.push(setMeshColor(id, value));
       } else if (key === "points") {
         promise_array.push(meshPointsStyle.applyMeshPointsStyle(id));
       } else if (key === "edges") {
@@ -58,7 +73,17 @@ export function useMeshStyle() {
         promise_array.push(meshPolygonsStyle.applyMeshPolygonsStyle(id));
       } else if (key === "polyhedra") {
         promise_array.push(meshPolyhedraStyle.applyMeshPolyhedraStyle(id));
-      } else if (key !== "attributes") {
+      } else if (
+        key === "corners" ||
+        key === "lines" ||
+        key === "surfaces" ||
+        key === "blocks" ||
+        key === "attributes" ||
+        key === "id"
+      ) {
+        // These keys are either handled elsewhere or not applicable to mesh objects
+        continue;
+      } else {
         throw new Error(`Unknown mesh key: ${key}`);
       }
     }
@@ -68,6 +93,8 @@ export function useMeshStyle() {
   return {
     meshVisibility,
     setMeshVisibility,
+    meshColor,
+    setMeshColor,
     applyMeshStyle,
     ...meshPointsStyle,
     ...meshEdgesStyle,

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

@@ -20,10 +20,10 @@ export function useMeshPointsColorStyle() {
       meshPointsColorSchemas,
       { id, color },
       {
-        response_function: () => {
-          meshPointsCommonStyle.meshPointsColoring(id).color = color;
-          console.log(setMeshPointsColor.name, { id }, JSON.stringify(meshPointsColor(id)));
-        },
+        response_function: () =>
+          meshPointsCommonStyle.mutateMeshPointsColoring(id, {
+            color,
+          }),
       },
     );
   }

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

@@ -3,6 +3,12 @@ import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state";
 export function useMeshPointsCommonStyle() {
   const dataStyleStateStore = useDataStyleStateStore();
 
+  function mutateMeshPointsStyle(id, values) {
+    return dataStyleStateStore.mutateStyle(id, {
+      points: values,
+    });
+  }
+
   function meshPointsStyle(id) {
     return dataStyleStateStore.getStyle(id).points;
   }
@@ -11,13 +17,16 @@ export function useMeshPointsCommonStyle() {
     return meshPointsStyle(id).coloring;
   }
 
-  function meshPointsActiveColoring(id) {
-    return meshPointsColoring(id).active;
+  function mutateMeshPointsColoring(id, values) {
+    return mutateMeshPointsStyle(id, {
+      coloring: values,
+    });
   }
 
   return {
     meshPointsStyle,
     meshPointsColoring,
-    meshPointsActiveColoring,
+    mutateMeshPointsStyle,
+    mutateMeshPointsColoring,
   };
 }