@geode/opengeodeweb-front 10.34.0-rc.9 → 10.34.0

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

@@ -1,19 +1,39 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports
-import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
 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,
+    collectionId?: 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,
+    collectionId?: string,
+  ) => Promise<unknown>;
+}
+
+export function useModelCornersColor(): ModelCornersColorApi {
+  const dataStore = useDataStore();
   const modelCommonStyle = useModelCommonStyle();
   const modelCornersCommonStyle = useModelCornersCommonStyle();
   const modelCornersVertexAttribute = useModelCornersVertexAttribute();
 
   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;
   }
 
@@ -21,13 +41,22 @@ export function useModelCornersColor() {
     return modelCornerColoring(id, corner_id).constant;
   }
 
-  function setModelCornersColor(
+  async function setModelCornersColor(
     modelId: string,
     corners_ids: string[],
     color: unknown,
     activeColoring = "constant",
-  ) {
-    return modelCommonStyle.setModelTypeColor(modelId, corners_ids, color, schema, activeColoring);
+    collectionId?: string,
+  ): Promise<unknown> {
+    const result = await modelCommonStyle.setModelTypeColor(
+      modelId,
+      corners_ids,
+      color,
+      schema,
+      activeColoring,
+      collectionId,
+    );
+    return result;
   }
 
   function modelCornerActiveColoring(id: string, corner_id?: string): unknown {
@@ -38,9 +67,11 @@ export function useModelCornersColor() {
     modelId: string,
     corners_ids: string[],
     activeColoring: string,
-  ) {
-    if (corners_ids.length > 1) {
-      modelCornersCommonStyle.mutateModelCornersTypeColoring(modelId, {
+    collectionId?: string,
+  ): Promise<unknown> {
+    const totalCornerIds = await dataStore.getCornersGeodeIds(modelId);
+    if (corners_ids.length === totalCornerIds.length) {
+      await modelCornersCommonStyle.mutateModelCornersTypeColoring(modelId, {
         active: activeColoring,
       });
     }
@@ -49,7 +80,7 @@ export function useModelCornersColor() {
     });
     if (activeColoring === "constant" || activeColoring === "random") {
       const color = modelCornerColor(modelId, corners_ids[0]);
-      return setModelCornersColor(modelId, corners_ids, color, activeColoring);
+      return setModelCornersColor(modelId, corners_ids, color, activeColoring, collectionId);
     }
 
     if (activeColoring === "vertex") {
@@ -78,6 +109,7 @@ export function useModelCornersColor() {
         );
       }
     }
+    return undefined;
   }
 
   return {

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

@@ -3,12 +3,26 @@ 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() {
+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 {
-    return dataStyleState.getStyle(id).corners as StyleValues;
+    const { corners } = dataStyleState.getStyle(id);
+    if (corners === undefined) {
+      return {};
+    }
+    return corners;
   }
 
   function modelComponentTypeCornersStyle(id: string): StyleValues {
@@ -27,17 +41,22 @@ export function useModelCornersCommonStyle() {
   }
 
   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;
   }
 
-  function mutateModelCornersColoring(id: string, corners_ids: string[], values: StyleValues) {
-    return modelCommonStyle.mutateComponentStyles(id, corners_ids, {
+  async function mutateModelCornersColoring(
+    id: string,
+    corners_ids: string[],
+    values: StyleValues,
+  ): Promise<void> {
+    await modelCommonStyle.mutateComponentStyles(id, corners_ids, {
       coloring: values,
     });
   }
 
-  function mutateModelCornersTypeColoring(id: string, values: StyleValues) {
-    return modelCommonStyle.mutateModelComponentTypeStyle(id, "Corner", {
+  async function mutateModelCornersTypeColoring(id: string, values: StyleValues): Promise<void> {
+    await modelCommonStyle.mutateModelComponentTypeStyle(id, "Corner", {
       coloring: values,
     });
   }

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

@@ -18,41 +18,57 @@ interface AttributeGroup {
   corners_ids: string[];
 }
 
-async function setModelCornersDefaultStyle(_id: 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: string, corners_ids: string[]) {
+  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: string, corners_ids: string[]) {
+  async function applyModelCornersColoringStyle(
+    modelId: string,
+    corners_ids: string[],
+  ): Promise<unknown[]> {
     const activeColoringGroups: Record<string, string[]> = {};
     for (const corner_id of corners_ids) {
       const activeColoring = String(modelColorStyle.modelCornerActiveColoring(modelId, corner_id));
-      if (!activeColoringGroups[activeColoring]) {
-        activeColoringGroups[activeColoring] = [];
-      }
+      activeColoringGroups[activeColoring] ??= [];
       activeColoringGroups[activeColoring].push(corner_id);
     }
 
@@ -64,15 +80,19 @@ export function useModelCornersStyle() {
         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(
@@ -102,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: string) {
+  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

@@ -33,6 +33,40 @@ interface AttributeInput {
   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,
@@ -50,11 +84,12 @@ function isModelCornersVertexAttributeValid({
 }
 
 // oxlint-disable-next-line max-lines-per-function
-function useModelCornersVertexAttribute() {
+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(
@@ -63,15 +98,12 @@ function useModelCornersVertexAttribute() {
     name: string | undefined,
     item: number | undefined,
   ): AttributeStoredConfig {
-    const { storedConfigs } = modelCornersVertexAttribute(modelId, cornerId);
-    if (
-      storedConfigs &&
-      name !== undefined &&
-      name in storedConfigs &&
-      item !== undefined &&
-      item in storedConfigs[name]!
-    ) {
-      return storedConfigs[name]![item]!;
+    const storedConfig =
+      name !== undefined && item !== undefined
+        ? modelCornersVertexAttribute(modelId, cornerId).storedConfigs?.[name]?.[item]
+        : undefined;
+    if (storedConfig !== undefined) {
+      return storedConfig;
     }
     return {
       minimum: undefined,
@@ -80,34 +112,36 @@ function useModelCornersVertexAttribute() {
       no_data_color: DEFAULT_NO_DATA_COLOR,
     };
   }
-  function mutateModelCornersVertexStyle(
+  async function mutateModelCornersVertexStyle(
     modelId: string,
     cornerIds: string[],
     values: Record<string, unknown>,
-  ) {
-    if (cornerIds.length > 1) {
-      modelCornersCommonStyle.mutateModelCornersTypeColoring(modelId, {
+  ): 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 }),
+      );
     }
-    return modelCornersCommonStyle.mutateModelCornersColoring(modelId, cornerIds, {
-      vertex: values,
-    });
+    await Promise.all(tasks);
   }
-  function setModelCornersVertexAttributeStoredConfig(
+  async function setModelCornersVertexAttributeStoredConfig(
     modelId: string,
     cornerIds: string[],
     name: string | undefined,
     item: number | undefined,
     config: Partial<AttributeStoredConfig>,
-  ) {
-    return mutateModelCornersVertexStyle(modelId, cornerIds, {
-      storedConfigs: {
-        [name as string]: {
-          lastItem: item,
-          [item as number]: config,
-        },
-      },
+  ): 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 {
@@ -118,11 +152,11 @@ function useModelCornersVertexAttribute() {
     cornerId: string | undefined,
     name: string | undefined,
   ): number {
-    const { storedConfigs } = modelCornersVertexAttribute(modelId, cornerId);
-    if (storedConfigs && name !== undefined && name in storedConfigs) {
-      return storedConfigs[name]!.lastItem;
+    if (name === undefined) {
+      return 0;
     }
-    return 0;
+    const { storedConfigs } = modelCornersVertexAttribute(modelId, cornerId);
+    return storedConfigs?.[name]?.lastItem ?? 0;
   }
   function modelCornersVertexAttributeItem(modelId: string, cornerId?: string): number {
     const vertexAttribute = modelCornersVertexAttribute(modelId, cornerId);
@@ -137,8 +171,12 @@ function useModelCornersVertexAttribute() {
   ): [number | undefined, number | undefined] {
     const name = modelCornersVertexAttributeName(modelId, cornerId);
     const item = modelCornersVertexAttributeItem(modelId, cornerId);
-    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item);
-    const { minimum, maximum } = storedConfig;
+    const { minimum, maximum } = modelCornersVertexAttributeStoredConfig(
+      modelId,
+      cornerId,
+      name,
+      item,
+    );
     return [minimum, maximum];
   }
   function modelCornersVertexAttributeColorMap(
@@ -147,8 +185,7 @@ function useModelCornersVertexAttribute() {
   ): string | undefined {
     const name = modelCornersVertexAttributeName(modelId, cornerId);
     const item = modelCornersVertexAttributeItem(modelId, cornerId);
-    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item);
-    return storedConfig.colorMap;
+    return modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item).colorMap;
   }
   async function setModelCornersVertexAttribute(
     modelId: string,
@@ -161,18 +198,15 @@ function useModelCornersVertexAttribute() {
       colorMap,
       no_data_color = DEFAULT_NO_DATA_COLOR,
     }: AttributeInput,
-  ) {
-    mutateModelCornersVertexStyle(modelId, cornerIds, {
-      name,
-      item,
-    });
-    setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, {
+  ): Promise<unknown> {
+    await mutateModelCornersVertexStyle(modelId, cornerIds, { name, item });
+    await setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, {
       minimum,
       maximum,
       colorMap,
       no_data_color,
     });
-    const points = getRGBPointsFromPreset(colorMap as string);
+    const points = getRGBPointsFromPreset(colorMap ?? "");
     const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, cornerIds);
     const params = {
       id: modelId,
@@ -184,12 +218,10 @@ function useModelCornersVertexAttribute() {
       maximum,
       no_data_color,
     };
-    return viewerStore.request({
-      schema: attributeSchema,
-      params,
-    });
+    const result = await viewerStore.request({ schema: attributeSchema, params });
+    return result;
   }
-  function applyVertexAttribute(modelId: string, cornerIds: string[]) {
+  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);
@@ -202,61 +234,60 @@ function useModelCornersVertexAttribute() {
       no_data_color: storedConfig.no_data_color,
     };
     if (isModelCornersVertexAttributeValid(attribute)) {
-      return setModelCornersVertexAttribute(modelId, cornerIds, attribute);
+      await setModelCornersVertexAttribute(modelId, cornerIds, attribute);
     }
-    return Promise.resolve();
   }
-  function setModelCornersVertexAttributeName(modelId: string, cornerIds: string[], name: string) {
+  async function setModelCornersVertexAttributeName(
+    modelId: string,
+    cornerIds: string[],
+    name: string,
+  ): Promise<void> {
     const item = modelCornersVertexAttributeLastItem(modelId, cornerIds[0], name);
-    mutateModelCornersVertexStyle(modelId, cornerIds, {
-      name,
-      item,
-    });
-    return applyVertexAttribute(modelId, cornerIds);
+    await mutateModelCornersVertexStyle(modelId, cornerIds, { name, item });
+    await applyVertexAttribute(modelId, cornerIds);
   }
-  function setModelCornersVertexAttributeItem(modelId: string, cornerIds: string[], item: number) {
-    mutateModelCornersVertexStyle(modelId, cornerIds, {
-      item,
-    });
-    return applyVertexAttribute(modelId, cornerIds);
+  async function setModelCornersVertexAttributeItem(
+    modelId: string,
+    cornerIds: string[],
+    item: number,
+  ): Promise<void> {
+    await mutateModelCornersVertexStyle(modelId, cornerIds, { item });
+    await applyVertexAttribute(modelId, cornerIds);
   }
-  function setModelCornersVertexAttributeRange(
+  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]);
-    setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, {
+    await setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, {
       minimum,
       maximum,
     });
-    return applyVertexAttribute(modelId, cornerIds);
+    await applyVertexAttribute(modelId, cornerIds);
   }
-  function setModelCornersVertexAttributeColorMap(
+  async function setModelCornersVertexAttributeColorMap(
     modelId: string,
     cornerIds: string[],
     colorMap: string | undefined,
-  ) {
+  ): Promise<void> {
     const name = modelCornersVertexAttributeName(modelId, cornerIds[0]);
     const item = modelCornersVertexAttributeItem(modelId, cornerIds[0]);
-    setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, {
-      colorMap,
-    });
-    return applyVertexAttribute(modelId, cornerIds);
+    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);
-    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item);
-    return storedConfig.no_data_color;
+    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);
@@ -264,7 +295,7 @@ function useModelCornersVertexAttribute() {
       ...storedConfig,
       no_data_color,
     });
-    return applyVertexAttribute(modelId, cornerIds);
+    await applyVertexAttribute(modelId, cornerIds);
   }
   return {
     modelCornersVertexAttributeName,

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

@@ -4,7 +4,16 @@ import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schem
 
 const schema = viewer_schemas.opengeodeweb_viewer.model.corners.visibility;
 
-export function useModelCornersVisibility() {
+interface ModelCornersVisibilityApi {
+  setModelCornersVisibility: (
+    modelId: string,
+    corners_ids: string[],
+    visibility: boolean | undefined,
+  ) => Promise<unknown>;
+  modelCornerVisibility: (id: string, corner_id?: string) => unknown;
+}
+
+export function useModelCornersVisibility(): ModelCornersVisibilityApi {
   const modelCommonStyle = useModelCommonStyle();
   const modelCornersCommonStyle = useModelCornersCommonStyle();
 
@@ -12,12 +21,18 @@ export function useModelCornersVisibility() {
     return modelCornersCommonStyle.modelCornerStyle(id, corner_id).visibility;
   }
 
-  function setModelCornersVisibility(
+  async function setModelCornersVisibility(
     modelId: string,
     corners_ids: string[],
     visibility: boolean | undefined,
-  ) {
-    return modelCommonStyle.setModelTypeVisibility(modelId, corners_ids, visibility, schema);
+  ): Promise<unknown> {
+    const result = await modelCommonStyle.setModelTypeVisibility(
+      modelId,
+      corners_ids,
+      visibility,
+      schema,
+    );
+    return result;
   }
 
   return { setModelCornersVisibility, modelCornerVisibility };