@geode/opengeodeweb-front 10.34.0-rc.2 → 10.34.0-rc.21

package/internal/stores/data_style/model/corners/{color.js → color.ts}

@@ -1,34 +1,72 @@
 import { isModelCornersVertexAttributeValid, useModelCornersVertexAttribute } from "./vertex";
+import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
+import { useDataStore } from "@ogw_front/stores/data";
 import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
 import { useModelCornersCommonStyle } from "./common";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 const schema = viewer_schemas.opengeodeweb_viewer.model.corners.color;
 
-export function useModelCornersColor() {
+interface ModelCornersColorApi {
+  setModelCornersColor: (
+    modelId: string,
+    corners_ids: string[],
+    color: unknown,
+    activeColoring?: string,
+  ) => Promise<unknown>;
+  modelCornerColoring: (id: string, corner_id?: string) => StyleValues;
+  modelCornerColor: (id: string, corner_id?: string) => unknown;
+  modelCornerActiveColoring: (id: string, corner_id?: string) => unknown;
+  setModelCornersActiveColoring: (
+    modelId: string,
+    corners_ids: string[],
+    activeColoring: string,
+  ) => Promise<unknown>;
+}
+
+export function useModelCornersColor(): ModelCornersColorApi {
+  const dataStore = useDataStore();
   const modelCommonStyle = useModelCommonStyle();
   const modelCornersCommonStyle = useModelCornersCommonStyle();
   const modelCornersVertexAttribute = useModelCornersVertexAttribute();
 
-  function modelCornerColoring(id, corner_id) {
-    return modelCornersCommonStyle.modelCornerStyle(id, corner_id).coloring;
+  function modelCornerColoring(id: string, corner_id?: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring is a StyleValues sub-object stored under a StyleValues index signature.
+    return modelCornersCommonStyle.modelCornerStyle(id, corner_id).coloring as StyleValues;
   }
 
-  function modelCornerColor(id, corner_id) {
+  function modelCornerColor(id: string, corner_id?: string): unknown {
     return modelCornerColoring(id, corner_id).constant;
   }
 
-  function setModelCornersColor(modelId, corners_ids, color, activeColoring = "constant") {
-    return modelCommonStyle.setModelTypeColor(modelId, corners_ids, color, schema, activeColoring);
+  async function setModelCornersColor(
+    modelId: string,
+    corners_ids: string[],
+    color: unknown,
+    activeColoring = "constant",
+  ): Promise<unknown> {
+    const result = await modelCommonStyle.setModelTypeColor(
+      modelId,
+      corners_ids,
+      color,
+      schema,
+      activeColoring,
+    );
+    return result;
   }
 
-  function modelCornerActiveColoring(id, corner_id) {
+  function modelCornerActiveColoring(id: string, corner_id?: string): unknown {
     return modelCornerColoring(id, corner_id).active;
   }
 
-  async function setModelCornersActiveColoring(modelId, corners_ids, activeColoring) {
-    if (corners_ids.length > 1) {
-      modelCornersCommonStyle.mutateModelCornersTypeColoring(modelId, {
+  async function setModelCornersActiveColoring(
+    modelId: string,
+    corners_ids: string[],
+    activeColoring: string,
+  ): Promise<unknown> {
+    const totalCornerIds = await dataStore.getCornersGeodeIds(modelId);
+    if (corners_ids.length === totalCornerIds.length) {
+      await modelCornersCommonStyle.mutateModelCornersTypeColoring(modelId, {
         active: activeColoring,
       });
     }
@@ -66,6 +104,7 @@ export function useModelCornersColor() {
         );
       }
     }
+    return undefined;
   }
 
   return {

package/internal/stores/data_style/model/corners/common.ts

@@ -0,0 +1,71 @@
+import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
+import merge from "lodash/merge";
+import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
+import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
+
+export function useModelCornersCommonStyle(): {
+  modelCornersStyle: (id: string) => StyleValues;
+  modelCornerStyle: (id: string, corner_id?: string) => StyleValues;
+  modelCornerColoring: (id: string, corner_id?: string) => StyleValues;
+  mutateModelCornersColoring: (
+    id: string,
+    corners_ids: string[],
+    values: StyleValues,
+  ) => Promise<void>;
+  mutateModelCornersTypeColoring: (id: string, values: StyleValues) => Promise<void>;
+} {
+  const dataStyleState = useDataStyleState();
+  const modelCommonStyle = useModelCommonStyle();
+
+  function modelCornersStyle(id: string): StyleValues {
+    const { corners } = dataStyleState.getStyle(id);
+    if (corners === undefined) {
+      return {};
+    }
+    return corners;
+  }
+
+  function modelComponentTypeCornersStyle(id: string): StyleValues {
+    const defaultStyle = modelCornersStyle(id);
+    const typeStyle = dataStyleState.getModelComponentTypeStyle(id, "Corner");
+    return merge({}, defaultStyle, typeStyle);
+  }
+
+  function modelCornerStyle(id: string, corner_id?: string): StyleValues {
+    if (corner_id === undefined) {
+      return modelComponentTypeCornersStyle(id);
+    }
+    const typeStyle = modelComponentTypeCornersStyle(id);
+    const individualStyle = dataStyleState.getComponentStyle(id, corner_id);
+    return merge({}, typeStyle, individualStyle);
+  }
+
+  function modelCornerColoring(id: string, corner_id?: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring is a StyleValues sub-object stored under a StyleValues index signature.
+    return modelCornerStyle(id, corner_id).coloring as StyleValues;
+  }
+
+  async function mutateModelCornersColoring(
+    id: string,
+    corners_ids: string[],
+    values: StyleValues,
+  ): Promise<void> {
+    await modelCommonStyle.mutateComponentStyles(id, corners_ids, {
+      coloring: values,
+    });
+  }
+
+  async function mutateModelCornersTypeColoring(id: string, values: StyleValues): Promise<void> {
+    await modelCommonStyle.mutateModelComponentTypeStyle(id, "Corner", {
+      coloring: values,
+    });
+  }
+
+  return {
+    modelCornersStyle,
+    modelCornerStyle,
+    modelCornerColoring,
+    mutateModelCornersColoring,
+    mutateModelCornersTypeColoring,
+  };
+}

package/internal/stores/data_style/model/corners/{index.js → index.ts}

@@ -4,68 +4,102 @@ import { useModelCornersColor } from "./color";
 import { useModelCornersCommonStyle } from "./common";
 import { useModelCornersVisibility } from "./visibility";
 
-async function setModelCornersDefaultStyle(_id) {
+interface ColorGroup {
+  color: unknown;
+  corners_ids: string[];
+}
+
+interface AttributeGroup {
+  name: string | undefined;
+  item: number | undefined;
+  minimum: number | undefined;
+  maximum: number | undefined;
+  colorMap: string | undefined;
+  corners_ids: string[];
+}
+
+async function setModelCornersDefaultStyle(_id: string): Promise<void> {
   // Placeholder
 }
 
-export function useModelCornersStyle() {
+type ModelCornersStyleApi = ReturnType<typeof useModelCornersCommonStyle> &
+  ReturnType<typeof useModelCornersVisibility> &
+  ReturnType<typeof useModelCornersColor> &
+  ReturnType<typeof useModelCornersVertexAttribute> & {
+    applyModelCornersStyle: (modelId: string) => Promise<void>;
+    setModelCornersDefaultStyle: (id: string) => Promise<void>;
+  };
+
+export function useModelCornersStyle(): ModelCornersStyleApi {
   const dataStore = useDataStore();
   const modelCommonStyle = useModelCornersCommonStyle();
   const modelVisibilityStyle = useModelCornersVisibility();
   const modelColorStyle = useModelCornersColor();
   const modelCornersVertexAttribute = useModelCornersVertexAttribute();
 
-  function applyModelCornersVisibilityStyle(modelId, corners_ids) {
-    const visibilityGroups = {};
+  async function applyModelCornersVisibilityStyle(
+    modelId: string,
+    corners_ids: string[],
+  ): Promise<unknown[]> {
+    const visibilityGroups: Record<string, string[]> = {};
     for (const corner_id of corners_ids) {
       const style = modelCommonStyle.modelCornerStyle(modelId, corner_id);
       const visibility = String(style.visibility);
-      if (!visibilityGroups[visibility]) {
-        visibilityGroups[visibility] = [];
-      }
+      visibilityGroups[visibility] ??= [];
       visibilityGroups[visibility].push(corner_id);
     }
-    return Promise.all(
-      Object.entries(visibilityGroups).map(([visibility, ids]) =>
-        modelVisibilityStyle.setModelCornersVisibility(modelId, ids, visibility === "true"),
-      ),
+    const results = await Promise.all(
+      Object.entries(visibilityGroups).map(async ([visibility, ids]) => {
+        const result = await modelVisibilityStyle.setModelCornersVisibility(
+          modelId,
+          ids,
+          visibility === "true",
+        );
+        return result;
+      }),
     );
+    return results;
   }
 
-  function applyModelCornersColoringStyle(modelId, corners_ids) {
-    const activeColoringGroups = {};
+  async function applyModelCornersColoringStyle(
+    modelId: string,
+    corners_ids: string[],
+  ): Promise<unknown[]> {
+    const activeColoringGroups: Record<string, string[]> = {};
     for (const corner_id of corners_ids) {
-      const activeColoring = modelColorStyle.modelCornerActiveColoring(modelId, corner_id);
-      if (!activeColoringGroups[activeColoring]) {
-        activeColoringGroups[activeColoring] = [];
-      }
+      const activeColoring = String(modelColorStyle.modelCornerActiveColoring(modelId, corner_id));
+      activeColoringGroups[activeColoring] ??= [];
       activeColoringGroups[activeColoring].push(corner_id);
     }
 
-    const coloringPromises = [];
+    const coloringPromises: Promise<unknown>[] = [];
 
     for (const [type, type_corners_ids] of Object.entries(activeColoringGroups)) {
       if (type === "constant") {
-        const colorGroups = {};
+        const colorGroups: Record<string, ColorGroup> = {};
         for (const corner_id of type_corners_ids) {
           const color = modelColorStyle.modelCornerColor(modelId, corner_id);
           const color_key = JSON.stringify(color);
-          if (!colorGroups[color_key]) {
-            colorGroups[color_key] = { color, corners_ids: [] };
-          }
+          colorGroups[color_key] ??= { color, corners_ids: [] };
           colorGroups[color_key].corners_ids.push(corner_id);
         }
         coloringPromises.push(
-          ...Object.values(colorGroups).map(({ color, corners_ids: ids }) =>
-            modelColorStyle.setModelCornersColor(modelId, ids, color, "constant"),
-          ),
+          ...Object.values(colorGroups).map(async ({ color, corners_ids: ids }) => {
+            const result = await modelColorStyle.setModelCornersColor(
+              modelId,
+              ids,
+              color,
+              "constant",
+            );
+            return result;
+          }),
         );
       } else if (type === "random") {
         coloringPromises.push(
           modelColorStyle.setModelCornersColor(modelId, type_corners_ids, undefined, "random"),
         );
       } else if (type === "vertex") {
-        const vertexGroups = {};
+        const vertexGroups: Record<string, AttributeGroup> = {};
         for (const corner_id of type_corners_ids) {
           const name = modelCornersVertexAttribute.modelCornersVertexAttributeName(
             modelId,
@@ -88,43 +122,48 @@ export function useModelCornersStyle() {
             continue;
           }
           const key = `${name}_${item}_${colorMap}_${minimum}_${maximum}`;
-          if (!vertexGroups[key]) {
-            vertexGroups[key] = {
-              name,
-              item,
-              minimum,
-              maximum,
-              colorMap,
-              corners_ids: [],
-            };
-          }
+          vertexGroups[key] ??= {
+            name,
+            item,
+            minimum,
+            maximum,
+            colorMap,
+            corners_ids: [],
+          };
           vertexGroups[key].corners_ids.push(corner_id);
         }
         coloringPromises.push(
           ...Object.values(vertexGroups).map(
-            ({ name, item, minimum, maximum, colorMap, corners_ids: ids }) =>
-              modelCornersVertexAttribute.setModelCornersVertexAttribute(modelId, ids, {
-                name,
-                item,
-                minimum,
-                maximum,
-                colorMap,
-              }),
+            async ({ name, item, minimum, maximum, colorMap, corners_ids: ids }) => {
+              const result = await modelCornersVertexAttribute.setModelCornersVertexAttribute(
+                modelId,
+                ids,
+                {
+                  name,
+                  item,
+                  minimum,
+                  maximum,
+                  colorMap,
+                },
+              );
+              return result;
+            },
           ),
         );
       }
     }
 
-    return Promise.all(coloringPromises);
+    const results = await Promise.all(coloringPromises);
+    return results;
   }
 
-  async function applyModelCornersStyle(modelId) {
+  async function applyModelCornersStyle(modelId: string): Promise<void> {
     const corners_ids = await dataStore.getCornersGeodeIds(modelId);
     if (corners_ids.length === 0) {
       return;
     }
 
-    return Promise.all([
+    await Promise.all([
       applyModelCornersVisibilityStyle(modelId, corners_ids),
       applyModelCornersColoringStyle(modelId, corners_ids),
     ]);

package/internal/stores/data_style/model/corners/vertex.ts

@@ -0,0 +1,315 @@
+import { DEFAULT_NO_DATA_COLOR } from "@ogw_front/utils/default_styles/constants";
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
+
+// Local imports
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
+import { useDataStore } from "@ogw_front/stores/data";
+import { useModelCornersCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
+
+// Local constants
+const attributeSchema = viewer_schemas.opengeodeweb_viewer.model.corners.attribute.vertex.attribute;
+
+interface AttributeStoredConfig {
+  minimum: number | undefined;
+  maximum: number | undefined;
+  colorMap: string | undefined;
+  no_data_color: unknown;
+}
+
+interface AttributeState {
+  name?: string;
+  item?: number;
+  storedConfigs?: Record<string, { lastItem: number } & Record<string, AttributeStoredConfig>>;
+}
+
+interface AttributeInput {
+  name: string | undefined;
+  item: number | undefined;
+  minimum: number | undefined;
+  maximum: number | undefined;
+  colorMap: string | undefined;
+  no_data_color?: unknown;
+}
+
+type IdsFn<Value> = (modelId: string, cornerIds: string[], value: Value) => Promise<void>;
+
+interface ModelCornersVertexAttributeApi {
+  modelCornersVertexAttributeName: (modelId: string, cornerId?: string) => string | undefined;
+  modelCornersVertexAttributeItem: (modelId: string, cornerId?: string) => number;
+  modelCornersVertexAttributeRange: (
+    modelId: string,
+    cornerId?: string,
+  ) => [number | undefined, number | undefined];
+  modelCornersVertexAttributeColorMap: (modelId: string, cornerId?: string) => string | undefined;
+  modelCornersVertexAttributeStoredConfig: (
+    modelId: string,
+    cornerId: string | undefined,
+    name: string | undefined,
+    item: number | undefined,
+  ) => AttributeStoredConfig;
+  setModelCornersVertexAttribute: (
+    modelId: string,
+    cornerIds: string[],
+    attribute: AttributeInput,
+  ) => Promise<unknown>;
+  setModelCornersVertexAttributeName: IdsFn<string>;
+  setModelCornersVertexAttributeItem: IdsFn<number>;
+  setModelCornersVertexAttributeRange: (
+    modelId: string,
+    cornerIds: string[],
+    minimum: number,
+    maximum: number,
+  ) => Promise<void>;
+  setModelCornersVertexAttributeColorMap: IdsFn<string | undefined>;
+  modelCornersVertexAttributeNoDataColor: (modelId: string, cornerId?: string) => unknown;
+  setModelCornersVertexAttributeNoDataColor: IdsFn<unknown>;
+}
+
+function isModelCornersVertexAttributeValid({
+  name,
+  item,
+  minimum,
+  maximum,
+  colorMap,
+}: AttributeInput): boolean {
+  return (
+    name !== undefined &&
+    item !== undefined &&
+    minimum !== undefined &&
+    maximum !== undefined &&
+    colorMap !== undefined
+  );
+}
+
+// oxlint-disable-next-line max-lines-per-function
+function useModelCornersVertexAttribute(): ModelCornersVertexAttributeApi {
+  const dataStore = useDataStore();
+  const modelCornersCommonStyle = useModelCornersCommonStyle();
+  const viewerStore = useViewerStore();
+  function modelCornersVertexAttribute(modelId: string, cornerId?: string): AttributeState {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- vertex is a StyleValues sub-object stored under a StyleValues index signature.
+    return modelCornersCommonStyle.modelCornerColoring(modelId, cornerId).vertex as AttributeState;
+  }
+  function modelCornersVertexAttributeStoredConfig(
+    modelId: string,
+    cornerId: string | undefined,
+    name: string | undefined,
+    item: number | undefined,
+  ): AttributeStoredConfig {
+    const storedConfig =
+      name !== undefined && item !== undefined
+        ? modelCornersVertexAttribute(modelId, cornerId).storedConfigs?.[name]?.[item]
+        : undefined;
+    if (storedConfig !== undefined) {
+      return storedConfig;
+    }
+    return {
+      minimum: undefined,
+      maximum: undefined,
+      colorMap: undefined,
+      no_data_color: DEFAULT_NO_DATA_COLOR,
+    };
+  }
+  async function mutateModelCornersVertexStyle(
+    modelId: string,
+    cornerIds: string[],
+    values: Record<string, unknown>,
+  ): Promise<void> {
+    const tasks: Promise<void>[] = [
+      modelCornersCommonStyle.mutateModelCornersColoring(modelId, cornerIds, {
+        vertex: values,
+      }),
+    ];
+    const totalCornerIds = await dataStore.getCornersGeodeIds(modelId);
+    if (cornerIds.length === totalCornerIds.length) {
+      tasks.push(
+        modelCornersCommonStyle.mutateModelCornersTypeColoring(modelId, { vertex: values }),
+      );
+    }
+    await Promise.all(tasks);
+  }
+  async function setModelCornersVertexAttributeStoredConfig(
+    modelId: string,
+    cornerIds: string[],
+    name: string | undefined,
+    item: number | undefined,
+    config: Partial<AttributeStoredConfig>,
+  ): Promise<void> {
+    if (name === undefined || item === undefined) {
+      return;
+    }
+    await mutateModelCornersVertexStyle(modelId, cornerIds, {
+      storedConfigs: { [name]: { lastItem: item, [item]: config } },
+    });
+  }
+  function modelCornersVertexAttributeName(modelId: string, cornerId?: string): string | undefined {
+    return modelCornersVertexAttribute(modelId, cornerId).name;
+  }
+  function modelCornersVertexAttributeLastItem(
+    modelId: string,
+    cornerId: string | undefined,
+    name: string | undefined,
+  ): number {
+    if (name === undefined) {
+      return 0;
+    }
+    const { storedConfigs } = modelCornersVertexAttribute(modelId, cornerId);
+    return storedConfigs?.[name]?.lastItem ?? 0;
+  }
+  function modelCornersVertexAttributeItem(modelId: string, cornerId?: string): number {
+    const vertexAttribute = modelCornersVertexAttribute(modelId, cornerId);
+    return (
+      vertexAttribute.item ??
+      modelCornersVertexAttributeLastItem(modelId, cornerId, vertexAttribute.name)
+    );
+  }
+  function modelCornersVertexAttributeRange(
+    modelId: string,
+    cornerId?: string,
+  ): [number | undefined, number | undefined] {
+    const name = modelCornersVertexAttributeName(modelId, cornerId);
+    const item = modelCornersVertexAttributeItem(modelId, cornerId);
+    const { minimum, maximum } = modelCornersVertexAttributeStoredConfig(
+      modelId,
+      cornerId,
+      name,
+      item,
+    );
+    return [minimum, maximum];
+  }
+  function modelCornersVertexAttributeColorMap(
+    modelId: string,
+    cornerId?: string,
+  ): string | undefined {
+    const name = modelCornersVertexAttributeName(modelId, cornerId);
+    const item = modelCornersVertexAttributeItem(modelId, cornerId);
+    return modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item).colorMap;
+  }
+  async function setModelCornersVertexAttribute(
+    modelId: string,
+    cornerIds: string[],
+    {
+      name,
+      item,
+      minimum,
+      maximum,
+      colorMap,
+      no_data_color = DEFAULT_NO_DATA_COLOR,
+    }: AttributeInput,
+  ): Promise<unknown> {
+    await mutateModelCornersVertexStyle(modelId, cornerIds, { name, item });
+    await setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, {
+      minimum,
+      maximum,
+      colorMap,
+      no_data_color,
+    });
+    const points = getRGBPointsFromPreset(colorMap ?? "");
+    const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, cornerIds);
+    const params = {
+      id: modelId,
+      block_ids: corner_viewer_ids,
+      name,
+      item,
+      points,
+      minimum,
+      maximum,
+      no_data_color,
+    };
+    const result = await viewerStore.request({ schema: attributeSchema, params });
+    return result;
+  }
+  async function applyVertexAttribute(modelId: string, cornerIds: string[]): Promise<void> {
+    const name = modelCornersVertexAttributeName(modelId, cornerIds[0]);
+    const item = modelCornersVertexAttributeItem(modelId, cornerIds[0]);
+    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerIds[0], name, item);
+    const attribute: AttributeInput = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+      no_data_color: storedConfig.no_data_color,
+    };
+    if (isModelCornersVertexAttributeValid(attribute)) {
+      await setModelCornersVertexAttribute(modelId, cornerIds, attribute);
+    }
+  }
+  async function setModelCornersVertexAttributeName(
+    modelId: string,
+    cornerIds: string[],
+    name: string,
+  ): Promise<void> {
+    const item = modelCornersVertexAttributeLastItem(modelId, cornerIds[0], name);
+    await mutateModelCornersVertexStyle(modelId, cornerIds, { name, item });
+    await applyVertexAttribute(modelId, cornerIds);
+  }
+  async function setModelCornersVertexAttributeItem(
+    modelId: string,
+    cornerIds: string[],
+    item: number,
+  ): Promise<void> {
+    await mutateModelCornersVertexStyle(modelId, cornerIds, { item });
+    await applyVertexAttribute(modelId, cornerIds);
+  }
+  async function setModelCornersVertexAttributeRange(
+    modelId: string,
+    cornerIds: string[],
+    minimum: number,
+    maximum: number,
+  ): Promise<void> {
+    const name = modelCornersVertexAttributeName(modelId, cornerIds[0]);
+    const item = modelCornersVertexAttributeItem(modelId, cornerIds[0]);
+    await setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, {
+      minimum,
+      maximum,
+    });
+    await applyVertexAttribute(modelId, cornerIds);
+  }
+  async function setModelCornersVertexAttributeColorMap(
+    modelId: string,
+    cornerIds: string[],
+    colorMap: string | undefined,
+  ): Promise<void> {
+    const name = modelCornersVertexAttributeName(modelId, cornerIds[0]);
+    const item = modelCornersVertexAttributeItem(modelId, cornerIds[0]);
+    await setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, { colorMap });
+    await applyVertexAttribute(modelId, cornerIds);
+  }
+  function modelCornersVertexAttributeNoDataColor(modelId: string, cornerId?: string): unknown {
+    const name = modelCornersVertexAttributeName(modelId, cornerId);
+    const item = modelCornersVertexAttributeItem(modelId, cornerId);
+    return modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item).no_data_color;
+  }
+  async function setModelCornersVertexAttributeNoDataColor(
+    modelId: string,
+    cornerIds: string[],
+    no_data_color: unknown,
+  ): Promise<void> {
+    const name = modelCornersVertexAttributeName(modelId, cornerIds[0]);
+    const item = modelCornersVertexAttributeItem(modelId, cornerIds[0]);
+    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerIds[0], name, item);
+    await setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, {
+      ...storedConfig,
+      no_data_color,
+    });
+    await applyVertexAttribute(modelId, cornerIds);
+  }
+  return {
+    modelCornersVertexAttributeName,
+    modelCornersVertexAttributeItem,
+    modelCornersVertexAttributeRange,
+    modelCornersVertexAttributeColorMap,
+    modelCornersVertexAttributeStoredConfig,
+    setModelCornersVertexAttribute,
+    setModelCornersVertexAttributeName,
+    setModelCornersVertexAttributeItem,
+    setModelCornersVertexAttributeRange,
+    setModelCornersVertexAttributeColorMap,
+    modelCornersVertexAttributeNoDataColor,
+    setModelCornersVertexAttributeNoDataColor,
+  };
+}
+export { isModelCornersVertexAttributeValid, useModelCornersVertexAttribute };