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

package/internal/stores/data_style/model/blocks/polyhedron.js

@@ -8,9 +8,21 @@ import { useModelBlocksCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const schema = viewer_schemas.opengeodeweb_viewer.model.blocks.attribute.polyhedron;
+const modelBlockPolyhedronAttributeSchema =
+  viewer_schemas.opengeodeweb_viewer.model.blocks.attribute.polyhedron.attribute;
+
+function isModelBlocksPolyhedronAttributeValid({ name, item, minimum, maximum, colorMap }) {
+  return (
+    name !== undefined &&
+    item !== undefined &&
+    minimum !== undefined &&
+    maximum !== undefined &&
+    colorMap !== undefined
+  );
+}
 
-export function useModelBlocksPolyhedronAttribute() {
+// oxlint-disable-next-line max-lines-per-function
+function useModelBlocksPolyhedronAttribute() {
   const dataStore = useDataStore();
   const modelBlocksCommonStyle = useModelBlocksCommonStyle();
   const viewerStore = useViewerStore();
@@ -19,16 +31,16 @@ export function useModelBlocksPolyhedronAttribute() {
     return modelBlocksCommonStyle.modelBlockColoring(modelId, blockId).polyhedron;
   }
 
-  function modelBlocksPolyhedronAttributeStoredConfig(modelId, blockId, name) {
+  function modelBlocksPolyhedronAttributeStoredConfig(modelId, blockId, name, item) {
     const { storedConfigs } = modelBlocksPolyhedronAttribute(modelId, blockId);
-    if (name in storedConfigs) {
-      return storedConfigs[name];
+    if (storedConfigs && name in storedConfigs && item in storedConfigs[name]) {
+      return storedConfigs[name][item];
     }
-    return setModelBlocksPolyhedronAttributeStoredConfig(modelId, [blockId], name, {
+    return {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    });
+    };
   }
 
   function mutateModelBlocksPolyhedronStyle(modelId, blockIds, values) {
@@ -37,10 +49,13 @@ export function useModelBlocksPolyhedronAttribute() {
     });
   }
 
-  function setModelBlocksPolyhedronAttributeStoredConfig(modelId, blockIds, name, config) {
+  function setModelBlocksPolyhedronAttributeStoredConfig(modelId, blockIds, name, item, config) {
     return mutateModelBlocksPolyhedronStyle(modelId, blockIds, {
       storedConfigs: {
-        [name]: config,
+        [name]: {
+          lastItem: item,
+          [item]: config,
+        },
       },
     });
   }
@@ -49,83 +64,124 @@ export function useModelBlocksPolyhedronAttribute() {
     return modelBlocksPolyhedronAttribute(modelId, blockId).name;
   }
 
-  async function setModelBlocksPolyhedronAttributeName(modelId, blockIds, name) {
-    const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, blockIds);
-    const params = { id: modelId, block_ids: viewer_ids, name };
-    return viewerStore.request(
-      { schema: schema.name, params },
-      {
-        response_function: () => mutateModelBlocksPolyhedronStyle(modelId, blockIds, { name }),
-      },
+  function modelBlocksPolyhedronAttributeItem(modelId, blockId) {
+    const polyhedronAttribute = modelBlocksPolyhedronAttribute(modelId, blockId);
+    return (
+      polyhedronAttribute.item ??
+      modelBlocksPolyhedronAttributeLastItem(modelId, blockId, polyhedronAttribute.name)
     );
   }
 
+  function modelBlocksPolyhedronAttributeLastItem(modelId, blockId, name) {
+    const { storedConfigs } = modelBlocksPolyhedronAttribute(modelId, blockId);
+    if (!(name in storedConfigs)) {
+      return 0;
+    }
+    return storedConfigs[name].lastItem;
+  }
+
   function modelBlocksPolyhedronAttributeRange(modelId, blockId) {
     const name = modelBlocksPolyhedronAttributeName(modelId, blockId);
-    const storedConfig = modelBlocksPolyhedronAttributeStoredConfig(modelId, blockId, name);
+    const item = modelBlocksPolyhedronAttributeItem(modelId, blockId);
+    const storedConfig = modelBlocksPolyhedronAttributeStoredConfig(modelId, blockId, name, item);
     const { minimum, maximum } = storedConfig;
     return [minimum, maximum];
   }
 
-  async function setModelBlocksPolyhedronAttributeRange(modelId, blockIds, minimum, maximum) {
-    const name = modelBlocksPolyhedronAttributeName(modelId, blockIds[0]);
-    const colorMap = modelBlocksPolyhedronAttributeColorMap(modelId, blockIds[0]);
-    const points = getRGBPointsFromPreset(colorMap);
+  function modelBlocksPolyhedronAttributeColorMap(modelId, blockId) {
+    const name = modelBlocksPolyhedronAttributeName(modelId, blockId);
+    const item = modelBlocksPolyhedronAttributeItem(modelId, blockId);
+    const storedConfig = modelBlocksPolyhedronAttributeStoredConfig(modelId, blockId, name, item);
+    return storedConfig.colorMap;
+  }
 
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, blockIds);
-      const params = { id: modelId, block_ids: viewer_ids, points, minimum, maximum };
-      return viewerStore.request(
-        { schema: schema.color_map, params },
-        {
-          response_function: () =>
-            setModelBlocksPolyhedronAttributeStoredConfig(modelId, blockIds, name, {
-              minimum,
-              maximum,
-            }),
-        },
-      );
+  function applyPolyhedronAttribute(modelId, blockIds) {
+    const name = modelBlocksPolyhedronAttributeName(modelId, blockIds[0]);
+    const item = modelBlocksPolyhedronAttributeItem(modelId, blockIds[0]);
+    const storedConfig = modelBlocksPolyhedronAttributeStoredConfig(
+      modelId,
+      blockIds[0],
+      name,
+      item,
+    );
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+    };
+    if (isModelBlocksPolyhedronAttributeValid(attribute)) {
+      return setModelBlocksPolyhedronAttribute(modelId, blockIds, attribute);
     }
-    return setModelBlocksPolyhedronAttributeStoredConfig(modelId, blockIds, name, {
+    return Promise.resolve();
+  }
+
+  function setModelBlocksPolyhedronAttributeName(modelId, blockIds, name) {
+    const item = modelBlocksPolyhedronAttributeLastItem(modelId, blockIds[0], name);
+    mutateModelBlocksPolyhedronStyle(modelId, blockIds, { name, item });
+    return applyPolyhedronAttribute(modelId, blockIds);
+  }
+
+  function setModelBlocksPolyhedronAttributeItem(modelId, blockIds, item) {
+    mutateModelBlocksPolyhedronStyle(modelId, blockIds, { item });
+    return applyPolyhedronAttribute(modelId, blockIds);
+  }
+
+  function setModelBlocksPolyhedronAttributeRange(modelId, blockIds, minimum, maximum) {
+    const name = modelBlocksPolyhedronAttributeName(modelId, blockIds[0]);
+    const item = modelBlocksPolyhedronAttributeItem(modelId, blockIds[0]);
+    setModelBlocksPolyhedronAttributeStoredConfig(modelId, blockIds, name, item, {
       minimum,
       maximum,
     });
+    return applyPolyhedronAttribute(modelId, blockIds);
   }
 
-  function modelBlocksPolyhedronAttributeColorMap(modelId, blockId) {
-    const name = modelBlocksPolyhedronAttributeName(modelId, blockId);
-    const storedConfig = modelBlocksPolyhedronAttributeStoredConfig(modelId, blockId, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
+  function setModelBlocksPolyhedronAttributeColorMap(modelId, blockIds, colorMap) {
+    const name = modelBlocksPolyhedronAttributeName(modelId, blockIds[0]);
+    const item = modelBlocksPolyhedronAttributeItem(modelId, blockIds[0]);
+    setModelBlocksPolyhedronAttributeStoredConfig(modelId, blockIds, name, item, { colorMap });
+    return applyPolyhedronAttribute(modelId, blockIds);
   }
 
-  async function setModelBlocksPolyhedronAttributeColorMap(modelId, blockIds, colorMap) {
-    const name = modelBlocksPolyhedronAttributeName(modelId, blockIds[0]);
-    const storedConfig = modelBlocksPolyhedronAttributeStoredConfig(modelId, blockIds[0], name);
+  async function setModelBlocksPolyhedronAttribute(
+    modelId,
+    blockIds,
+    { name, item, minimum, maximum, colorMap },
+  ) {
+    mutateModelBlocksPolyhedronStyle(modelId, blockIds, { name, item });
+    setModelBlocksPolyhedronAttributeStoredConfig(modelId, blockIds, name, item, {
+      minimum,
+      maximum,
+      colorMap,
+    });
     const points = getRGBPointsFromPreset(colorMap);
-    const { minimum, maximum } = storedConfig;
-
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, blockIds);
-      const params = { id: modelId, block_ids: viewer_ids, points, minimum, maximum };
-      return viewerStore.request(
-        { schema: schema.color_map, params },
-        {
-          response_function: () =>
-            setModelBlocksPolyhedronAttributeStoredConfig(modelId, blockIds, name, { colorMap }),
-        },
-      );
-    }
-    return setModelBlocksPolyhedronAttributeStoredConfig(modelId, blockIds, name, { colorMap });
+    const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, blockIds);
+    const params = {
+      id: modelId,
+      block_ids: viewer_ids,
+      name,
+      item,
+      points,
+      minimum,
+      maximum,
+    };
+    return viewerStore.request({ schema: modelBlockPolyhedronAttributeSchema, params });
   }
 
   return {
     modelBlocksPolyhedronAttributeName,
+    modelBlocksPolyhedronAttributeItem,
     modelBlocksPolyhedronAttributeRange,
     modelBlocksPolyhedronAttributeColorMap,
     modelBlocksPolyhedronAttributeStoredConfig,
+    setModelBlocksPolyhedronAttribute,
     setModelBlocksPolyhedronAttributeName,
+    setModelBlocksPolyhedronAttributeItem,
     setModelBlocksPolyhedronAttributeRange,
     setModelBlocksPolyhedronAttributeColorMap,
   };
 }
+
+export { isModelBlocksPolyhedronAttributeValid, useModelBlocksPolyhedronAttribute };

package/internal/stores/data_style/model/blocks/vertex.js

@@ -8,9 +8,20 @@ import { useModelBlocksCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const schema = viewer_schemas.opengeodeweb_viewer.model.blocks.attribute.vertex;
+const attributeSchema = viewer_schemas.opengeodeweb_viewer.model.blocks.attribute.vertex.attribute;
+
+function isModelBlocksVertexAttributeValid({ name, item, minimum, maximum, colorMap }) {
+  return (
+    name !== undefined &&
+    item !== undefined &&
+    minimum !== undefined &&
+    maximum !== undefined &&
+    colorMap !== undefined
+  );
+}
 
-export function useModelBlocksVertexAttribute() {
+// oxlint-disable-next-line max-lines-per-function
+function useModelBlocksVertexAttribute() {
   const dataStore = useDataStore();
   const modelBlocksCommonStyle = useModelBlocksCommonStyle();
   const viewerStore = useViewerStore();
@@ -19,16 +30,16 @@ export function useModelBlocksVertexAttribute() {
     return modelBlocksCommonStyle.modelBlockColoring(modelId, blockId).vertex;
   }
 
-  function modelBlocksVertexAttributeStoredConfig(modelId, blockId, name) {
+  function modelBlocksVertexAttributeStoredConfig(modelId, blockId, name, item) {
     const { storedConfigs } = modelBlocksVertexAttribute(modelId, blockId);
-    if (name in storedConfigs) {
-      return storedConfigs[name];
+    if (storedConfigs && name in storedConfigs && item in storedConfigs[name]) {
+      return storedConfigs[name][item];
     }
-    return setModelBlocksVertexAttributeStoredConfig(modelId, [blockId], name, {
+    return {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    });
+    };
   }
 
   function mutateModelBlocksVertexStyle(modelId, blockIds, values) {
@@ -37,10 +48,13 @@ export function useModelBlocksVertexAttribute() {
     });
   }
 
-  function setModelBlocksVertexAttributeStoredConfig(modelId, blockIds, name, config) {
+  function setModelBlocksVertexAttributeStoredConfig(modelId, blockIds, name, item, config) {
     return mutateModelBlocksVertexStyle(modelId, blockIds, {
       storedConfigs: {
-        [name]: config,
+        [name]: {
+          lastItem: item,
+          [item]: config,
+        },
       },
     });
   }
@@ -49,80 +63,116 @@ export function useModelBlocksVertexAttribute() {
     return modelBlocksVertexAttribute(modelId, blockId).name;
   }
 
-  async function setModelBlocksVertexAttributeName(modelId, blockIds, name) {
-    const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, blockIds);
-    const params = { id: modelId, block_ids: viewer_ids, name };
-    return viewerStore.request(
-      { schema: schema.name, params },
-      {
-        response_function: () => mutateModelBlocksVertexStyle(modelId, blockIds, { name }),
-      },
+  function modelBlocksVertexAttributeItem(modelId, blockId) {
+    const vertexAttribute = modelBlocksVertexAttribute(modelId, blockId);
+    return (
+      vertexAttribute.item ??
+      modelBlocksVertexAttributeLastItem(modelId, blockId, vertexAttribute.name)
     );
   }
 
+  function modelBlocksVertexAttributeLastItem(modelId, blockId, name) {
+    const { storedConfigs } = modelBlocksVertexAttribute(modelId, blockId);
+    if (!(name in storedConfigs)) {
+      return 0;
+    }
+    return storedConfigs[name].lastItem;
+  }
+
   function modelBlocksVertexAttributeRange(modelId, blockId) {
     const name = modelBlocksVertexAttributeName(modelId, blockId);
-    const storedConfig = modelBlocksVertexAttributeStoredConfig(modelId, blockId, name);
+    const item = modelBlocksVertexAttributeItem(modelId, blockId);
+    const storedConfig = modelBlocksVertexAttributeStoredConfig(modelId, blockId, name, item);
     const { minimum, maximum } = storedConfig;
     return [minimum, maximum];
   }
 
-  async function setModelBlocksVertexAttributeRange(modelId, blockIds, minimum, maximum) {
-    const name = modelBlocksVertexAttributeName(modelId, blockIds[0]);
-    const colorMap = modelBlocksVertexAttributeColorMap(modelId, blockIds[0]);
-    const points = getRGBPointsFromPreset(colorMap);
+  function modelBlocksVertexAttributeColorMap(modelId, blockId) {
+    const name = modelBlocksVertexAttributeName(modelId, blockId);
+    const item = modelBlocksVertexAttributeItem(modelId, blockId);
+    const storedConfig = modelBlocksVertexAttributeStoredConfig(modelId, blockId, name, item);
+    return storedConfig.colorMap;
+  }
 
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, blockIds);
-      const params = { id: modelId, block_ids: viewer_ids, points, minimum, maximum };
-      return viewerStore.request(
-        { schema: schema.color_map, params },
-        {
-          response_function: () =>
-            setModelBlocksVertexAttributeStoredConfig(modelId, blockIds, name, {
-              minimum,
-              maximum,
-            }),
-        },
-      );
+  function applyVertexAttribute(modelId, blockIds) {
+    const name = modelBlocksVertexAttributeName(modelId, blockIds[0]);
+    const item = modelBlocksVertexAttributeItem(modelId, blockIds[0]);
+    const storedConfig = modelBlocksVertexAttributeStoredConfig(modelId, blockIds[0], name, item);
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+    };
+    if (isModelBlocksVertexAttributeValid(attribute)) {
+      return setModelBlocksVertexAttribute(modelId, blockIds, attribute);
     }
-    return setModelBlocksVertexAttributeStoredConfig(modelId, blockIds, name, { minimum, maximum });
+    return Promise.resolve();
   }
 
-  function modelBlocksVertexAttributeColorMap(modelId, blockId) {
-    const name = modelBlocksVertexAttributeName(modelId, blockId);
-    const storedConfig = modelBlocksVertexAttributeStoredConfig(modelId, blockId, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
+  function setModelBlocksVertexAttributeName(modelId, blockIds, name) {
+    const item = modelBlocksVertexAttributeLastItem(modelId, blockIds[0], name);
+    mutateModelBlocksVertexStyle(modelId, blockIds, { name, item });
+    return applyVertexAttribute(modelId, blockIds);
+  }
+
+  function setModelBlocksVertexAttributeItem(modelId, blockIds, item) {
+    mutateModelBlocksVertexStyle(modelId, blockIds, { item });
+    return applyVertexAttribute(modelId, blockIds);
   }
 
-  async function setModelBlocksVertexAttributeColorMap(modelId, blockIds, colorMap) {
+  function setModelBlocksVertexAttributeRange(modelId, blockIds, minimum, maximum) {
     const name = modelBlocksVertexAttributeName(modelId, blockIds[0]);
-    const storedConfig = modelBlocksVertexAttributeStoredConfig(modelId, blockIds[0], name);
-    const points = getRGBPointsFromPreset(colorMap);
-    const { minimum, maximum } = storedConfig;
+    const item = modelBlocksVertexAttributeItem(modelId, blockIds[0]);
+    setModelBlocksVertexAttributeStoredConfig(modelId, blockIds, name, item, { minimum, maximum });
+    return applyVertexAttribute(modelId, blockIds);
+  }
 
-    if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
-      const viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, blockIds);
-      const params = { id: modelId, block_ids: viewer_ids, points, minimum, maximum };
-      return viewerStore.request(
-        { schema: schema.color_map, params },
-        {
-          response_function: () =>
-            setModelBlocksVertexAttributeStoredConfig(modelId, blockIds, name, { colorMap }),
-        },
-      );
-    }
-    return setModelBlocksVertexAttributeStoredConfig(modelId, blockIds, name, { colorMap });
+  function setModelBlocksVertexAttributeColorMap(modelId, blockIds, colorMap) {
+    const name = modelBlocksVertexAttributeName(modelId, blockIds[0]);
+    const item = modelBlocksVertexAttributeItem(modelId, blockIds[0]);
+    setModelBlocksVertexAttributeStoredConfig(modelId, blockIds, name, item, { colorMap });
+    return applyVertexAttribute(modelId, blockIds);
+  }
+
+  async function setModelBlocksVertexAttribute(
+    modelId,
+    blockIds,
+    { name, item, minimum, maximum, colorMap },
+  ) {
+    mutateModelBlocksVertexStyle(modelId, blockIds, { name, item });
+    setModelBlocksVertexAttributeStoredConfig(modelId, blockIds, name, item, {
+      minimum,
+      maximum,
+      colorMap,
+    });
+    const points = getRGBPointsFromPreset(colorMap);
+    const block_viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, blockIds);
+    const params = {
+      id: modelId,
+      block_ids: block_viewer_ids,
+      name,
+      item,
+      points,
+      minimum,
+      maximum,
+    };
+    return viewerStore.request({ schema: attributeSchema, params });
   }
 
   return {
     modelBlocksVertexAttributeName,
+    modelBlocksVertexAttributeItem,
     modelBlocksVertexAttributeRange,
     modelBlocksVertexAttributeColorMap,
     modelBlocksVertexAttributeStoredConfig,
+    setModelBlocksVertexAttribute,
     setModelBlocksVertexAttributeName,
+    setModelBlocksVertexAttributeItem,
     setModelBlocksVertexAttributeRange,
     setModelBlocksVertexAttributeColorMap,
   };
 }
+
+export { isModelBlocksVertexAttributeValid, useModelBlocksVertexAttribute };

package/internal/stores/data_style/model/common.js

@@ -20,9 +20,9 @@ export function useModelCommonStyle() {
     return model_component_datastyle_db.put(structuredClone(toRaw(entry)));
   }
 
-  function mutateModelComponentTypeStyle(id_model, type, values) {
+  async function mutateModelComponentTypeStyle(id_model, type, values) {
     dataStyleState.updateModelComponentTypeStyleCache(id_model, type, values);
-    return database.transaction("rw", model_component_type_datastyle_db, async () => {
+    await database.transaction("rw", model_component_type_datastyle_db, async () => {
       const key = [id_model, type];
       const entry = (await model_component_type_datastyle_db.get(key)) || { id_model, type };
       merge(entry, values);
@@ -30,9 +30,9 @@ export function useModelCommonStyle() {
     });
   }
 
-  function mutateComponentStyles(id_model, id_components, values) {
+  async function mutateComponentStyles(id_model, id_components, values) {
     dataStyleState.bulkUpdateComponentStylesCache(id_model, id_components, values);
-    return database.transaction("rw", model_component_datastyle_db, async () => {
+    await database.transaction("rw", model_component_datastyle_db, async () => {
       const keys = id_components.map((id_component) => [id_model, id_component]);
       const existing = await model_component_datastyle_db.bulkGet(keys);
       const updates = id_components.map((id_component, index) => {
@@ -45,9 +45,9 @@ export function useModelCommonStyle() {
     });
   }
 
-  function bulkMutateComponentStylesPerComponent(id_model, component_updates) {
+  async function bulkMutateComponentStylesPerComponent(id_model, component_updates) {
     dataStyleState.bulkUpdateComponentStyleCache(id_model, component_updates);
-    return database.transaction("rw", model_component_datastyle_db, async () => {
+    await database.transaction("rw", model_component_datastyle_db, async () => {
       const keys = component_updates.map((update) => [id_model, update.id_component]);
       const existing = await model_component_datastyle_db.bulkGet(keys);
       const updates = component_updates.map(({ id_component, values }, index) => {

package/internal/stores/data_style/model/corners/color.js

@@ -1,6 +1,6 @@
+import { isModelCornersVertexAttributeValid, useModelCornersVertexAttribute } from "./vertex";
 import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
 import { useModelCornersCommonStyle } from "./common";
-import { useModelCornersVertexAttribute } from "./vertex";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 const schema = viewer_schemas.opengeodeweb_viewer.model.corners.color;
@@ -40,30 +40,26 @@ export function useModelCornersColor() {
         modelId,
         corners_ids[0],
       );
-      await modelCornersVertexAttribute.setModelCornersVertexAttributeName(
-        modelId,
-        corners_ids,
-        name,
-      );
-      const [min, max] = modelCornersVertexAttribute.modelCornersVertexAttributeRange(
+      const item = modelCornersVertexAttribute.modelCornersVertexAttributeItem(
         modelId,
         corners_ids[0],
       );
-      await modelCornersVertexAttribute.setModelCornersVertexAttributeRange(
+      const [minimum, maximum] = modelCornersVertexAttribute.modelCornersVertexAttributeRange(
         modelId,
-        corners_ids,
-        min,
-        max,
+        corners_ids[0],
       );
       const colorMap = modelCornersVertexAttribute.modelCornersVertexAttributeColorMap(
         modelId,
         corners_ids[0],
       );
-      await modelCornersVertexAttribute.setModelCornersVertexAttributeColorMap(
-        modelId,
-        corners_ids,
-        colorMap,
-      );
+      const attribute = { name, item, minimum, maximum, colorMap };
+      if (isModelCornersVertexAttributeValid(attribute)) {
+        return modelCornersVertexAttribute.setModelCornersVertexAttribute(
+          modelId,
+          corners_ids,
+          attribute,
+        );
+      }
     }
   }