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

package/internal/stores/data_style/mesh/cells/common.ts

@@ -1,33 +1,43 @@
 import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
 import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
 
-export function useMeshCellsCommonStyle() {
+export function useMeshCellsCommonStyle(): {
+  meshCellsStyle: (id: string) => StyleValues;
+  meshCellsColoring: (id: string) => StyleValues;
+  mutateMeshCellsStyle: (id: string, values: StyleValues) => Promise<string>;
+  mutateMeshCellsColoring: (id: string, values: StyleValues) => Promise<string>;
+  mutateMeshCellsCellStyle: (id: string, values: StyleValues) => Promise<string>;
+} {
   const dataStyleState = useDataStyleState();
 
-  function mutateMeshCellsStyle(id: string, values: StyleValues) {
-    return dataStyleState.mutateStyle(id, {
+  async function mutateMeshCellsStyle(id: string, values: StyleValues): Promise<string> {
+    const result = await dataStyleState.mutateStyle(id, {
       cells: values,
     });
+    return result;
   }
 
   function meshCellsStyle(id: string): StyleValues {
-    return dataStyleState.getStyle(id).cells as StyleValues;
+    return dataStyleState.getStyle(id).cells ?? {};
   }
 
   function meshCellsColoring(id: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring shape is defined by the data style schema.
     return meshCellsStyle(id).coloring as StyleValues;
   }
 
-  function mutateMeshCellsColoring(id: string, values: StyleValues) {
-    return mutateMeshCellsStyle(id, {
+  async function mutateMeshCellsColoring(id: string, values: StyleValues): Promise<string> {
+    const result = await mutateMeshCellsStyle(id, {
       coloring: values,
     });
+    return result;
   }
 
-  function mutateMeshCellsCellStyle(id: string, values: StyleValues) {
-    return mutateMeshCellsColoring(id, {
+  async function mutateMeshCellsCellStyle(id: string, values: StyleValues): Promise<string> {
+    const result = await mutateMeshCellsColoring(id, {
       cell: values,
     });
+    return result;
   }
 
   return {

package/internal/stores/data_style/mesh/cells/index.ts

@@ -3,6 +3,7 @@
 // Local imports
 import { isMeshCellsCellAttributeValid, useMeshCellsCellAttributeStyle } from "./cell";
 import { isMeshCellsVertexAttributeValid, useMeshCellsVertexAttributeStyle } from "./vertex";
+import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
 import { useMeshCellsColorStyle } from "./color";
 import { useMeshCellsCommonStyle } from "./common";
 import { useMeshCellsTexturesStyle } from "./textures";
@@ -10,68 +11,147 @@ import { useMeshCellsVisibilityStyle } from "./visibility";
 
 // Local constants
 
-export function useMeshCellsStyle() {
+interface MeshCellsActiveColoringDeps {
+  readonly commonStyle: ReturnType<typeof useMeshCellsCommonStyle>;
+  readonly colorStyle: ReturnType<typeof useMeshCellsColorStyle>;
+  readonly texturesStyle: ReturnType<typeof useMeshCellsTexturesStyle>;
+  readonly vertexAttributeStyle: ReturnType<typeof useMeshCellsVertexAttributeStyle>;
+  readonly cellAttributeStyle: ReturnType<typeof useMeshCellsCellAttributeStyle>;
+}
+
+function handleMeshCellsVertexColoring(
+  id: string,
+  vertexAttributeStyle: ReturnType<typeof useMeshCellsVertexAttributeStyle>,
+): Promise<unknown> | undefined {
+  const name = vertexAttributeStyle.meshCellsVertexAttributeName(id);
+  const item = vertexAttributeStyle.meshCellsVertexAttributeItem(id);
+  const [minimum, maximum] = vertexAttributeStyle.meshCellsVertexAttributeRange(id);
+  const colorMap = vertexAttributeStyle.meshCellsVertexAttributeColorMap(id);
+  const vertex_attribute = { name, item, minimum, maximum, colorMap };
+  if (!isMeshCellsVertexAttributeValid(vertex_attribute)) {
+    return undefined;
+  }
+  return vertexAttributeStyle.setMeshCellsVertexAttribute(id, vertex_attribute);
+}
+
+function handleMeshCellsCellColoring(
+  id: string,
+  cellAttributeStyle: ReturnType<typeof useMeshCellsCellAttributeStyle>,
+): Promise<unknown> | undefined {
+  const name = cellAttributeStyle.meshCellsCellAttributeName(id);
+  const item = cellAttributeStyle.meshCellsCellAttributeItem(id);
+  const [minimum, maximum] = cellAttributeStyle.meshCellsCellAttributeRange(id);
+  const colorMap = cellAttributeStyle.meshCellsCellAttributeColorMap(id);
+  const cell_attribute = { name, item, minimum, maximum, colorMap };
+  if (!isMeshCellsCellAttributeValid(cell_attribute)) {
+    return undefined;
+  }
+  return cellAttributeStyle.setMeshCellsCellAttribute(id, cell_attribute);
+}
+
+async function setMeshCellsActiveColoring(
+  id: string,
+  type: string | undefined,
+  deps: MeshCellsActiveColoringDeps,
+): Promise<unknown> {
+  await deps.commonStyle.mutateMeshCellsStyle(id, {
+    coloring: { active: type },
+  });
+  if (type === "constant") {
+    const result = await deps.colorStyle.setMeshCellsColor(id, deps.colorStyle.meshCellsColor(id));
+    return result;
+  }
+  if (type === "textures") {
+    const result = await deps.texturesStyle.setMeshCellsTextures(
+      id,
+      deps.texturesStyle.meshCellsTextures(id),
+    );
+    return result;
+  }
+  if (type === "vertex") {
+    const result = await handleMeshCellsVertexColoring(id, deps.vertexAttributeStyle);
+    return result;
+  }
+  if (type === "cell") {
+    const result = await handleMeshCellsCellColoring(id, deps.cellAttributeStyle);
+    return result;
+  }
+  throw new Error(`Unknown mesh cells coloring type: ${type}`);
+}
+
+async function applyMeshCellsStyle(
+  id: string,
+  visibilityStyle: ReturnType<typeof useMeshCellsVisibilityStyle>,
+  activeColoringType: string | undefined,
+  deps: MeshCellsActiveColoringDeps,
+): Promise<unknown[]> {
+  const result = await Promise.all([
+    visibilityStyle.setMeshCellsVisibility(id, visibilityStyle.meshCellsVisibility(id)),
+    setMeshCellsActiveColoring(id, activeColoringType, deps),
+  ]);
+  return result;
+}
+
+type UseMeshCellsStyleReturn = ReturnType<typeof useMeshCellsCommonStyle> & {
+  meshCellsColoring: (id: string) => StyleValues;
+  meshCellsActiveColoring: (id: string) => string | undefined;
+  setMeshCellsActiveColoring: (id: string, type: string | undefined) => Promise<unknown>;
+  applyMeshCellsStyle: (id: string) => Promise<unknown[]>;
+} & ReturnType<typeof useMeshCellsVisibilityStyle> &
+  ReturnType<typeof useMeshCellsColorStyle> &
+  ReturnType<typeof useMeshCellsTexturesStyle> &
+  ReturnType<typeof useMeshCellsVertexAttributeStyle> &
+  ReturnType<typeof useMeshCellsCellAttributeStyle>;
+
+export function useMeshCellsStyle(): UseMeshCellsStyleReturn {
   const meshCellsCommonStyle = useMeshCellsCommonStyle();
   const meshCellsVisibility = useMeshCellsVisibilityStyle();
   const meshCellsColorStyle = useMeshCellsColorStyle();
   const meshCellsTexturesStore = useMeshCellsTexturesStyle();
+  const meshCellsVertexAttributeStyle = useMeshCellsVertexAttributeStyle();
+  const meshCellsCellAttributeStyle = useMeshCellsCellAttributeStyle();
+
+  const activeColoringDeps: MeshCellsActiveColoringDeps = {
+    commonStyle: meshCellsCommonStyle,
+    colorStyle: meshCellsColorStyle,
+    texturesStyle: meshCellsTexturesStore,
+    vertexAttributeStyle: meshCellsVertexAttributeStyle,
+    cellAttributeStyle: meshCellsCellAttributeStyle,
+  };
 
-  function meshCellsColoring(id: string) {
+  function meshCellsColoring(id: string): StyleValues {
     return meshCellsCommonStyle.meshCellsColoring(id);
   }
-  const meshCellsVertexAttributeStyle = useMeshCellsVertexAttributeStyle();
-  const meshCellsCellAttributeStyle = useMeshCellsCellAttributeStyle();
 
   function meshCellsActiveColoring(id: string): string | undefined {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring.active is defined as string in the data style schema.
     return meshCellsColoring(id).active as string | undefined;
   }
 
-  async function setMeshCellsActiveColoring(id: string, type: string | undefined) {
-    await meshCellsCommonStyle.mutateMeshCellsStyle(id, {
-      coloring: { active: type },
-    });
-    if (type === "constant") {
-      return meshCellsColorStyle.setMeshCellsColor(id, meshCellsColorStyle.meshCellsColor(id));
-    } else if (type === "textures") {
-      const textures = meshCellsTexturesStore.meshCellsTextures(id);
-      return meshCellsTexturesStore.setMeshCellsTextures(id, textures);
-    } else if (type === "vertex") {
-      const name = meshCellsVertexAttributeStyle.meshCellsVertexAttributeName(id);
-      const item = meshCellsVertexAttributeStyle.meshCellsVertexAttributeItem(id);
-      const [minimum, maximum] = meshCellsVertexAttributeStyle.meshCellsVertexAttributeRange(id);
-      const colorMap = meshCellsVertexAttributeStyle.meshCellsVertexAttributeColorMap(id);
-      const vertex_attribute = { name, item, minimum, maximum, colorMap };
-      if (!isMeshCellsVertexAttributeValid(vertex_attribute)) {
-        return;
-      }
-      return meshCellsVertexAttributeStyle.setMeshCellsVertexAttribute(id, vertex_attribute);
-    } else if (type === "cell") {
-      const name = meshCellsCellAttributeStyle.meshCellsCellAttributeName(id);
-      const item = meshCellsCellAttributeStyle.meshCellsCellAttributeItem(id);
-      const [minimum, maximum] = meshCellsCellAttributeStyle.meshCellsCellAttributeRange(id);
-      const colorMap = meshCellsCellAttributeStyle.meshCellsCellAttributeColorMap(id);
-      const cell_attribute = { name, item, minimum, maximum, colorMap };
-      if (!isMeshCellsCellAttributeValid(cell_attribute)) {
-        return;
-      }
-      return meshCellsCellAttributeStyle.setMeshCellsCellAttribute(id, cell_attribute);
-    }
-    throw new Error(`Unknown mesh cells coloring type: ${type}`);
+  async function boundSetMeshCellsActiveColoring(
+    id: string,
+    type: string | undefined,
+  ): Promise<unknown> {
+    const result = await setMeshCellsActiveColoring(id, type, activeColoringDeps);
+    return result;
   }
 
-  function applyMeshCellsStyle(id: string) {
-    return Promise.all([
-      meshCellsVisibility.setMeshCellsVisibility(id, meshCellsVisibility.meshCellsVisibility(id)),
-      setMeshCellsActiveColoring(id, meshCellsActiveColoring(id)),
-    ]);
+  async function boundApplyMeshCellsStyle(id: string): Promise<unknown[]> {
+    const result = await applyMeshCellsStyle(
+      id,
+      meshCellsVisibility,
+      meshCellsActiveColoring(id),
+      activeColoringDeps,
+    );
+    return result;
   }
 
   return {
     ...meshCellsCommonStyle,
     meshCellsColoring,
     meshCellsActiveColoring,
-    setMeshCellsActiveColoring,
-    applyMeshCellsStyle,
+    setMeshCellsActiveColoring: boundSetMeshCellsActiveColoring,
+    applyMeshCellsStyle: boundApplyMeshCellsStyle,
     ...meshCellsVisibility,
     ...meshCellsColorStyle,
     ...meshCellsTexturesStore,

package/internal/stores/data_style/mesh/cells/textures.ts

@@ -8,27 +8,33 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const schema = viewer_schemas.opengeodeweb_viewer.mesh.apply_textures;
 
-export function useMeshCellsTexturesStyle() {
+export function useMeshCellsTexturesStyle(): {
+  meshCellsTextures: (id: string) => unknown;
+  setMeshCellsTextures: (id: string, textures: unknown) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const meshCellsCommonStyle = useMeshCellsCommonStyle();
 
   function meshCellsTextures(id: string): unknown {
     return meshCellsCommonStyle.meshCellsColoring(id).textures;
   }
-  function setMeshCellsTextures(id: string, textures: unknown) {
+  async function setMeshCellsTextures(id: string, textures: unknown): Promise<unknown> {
     const params = { id, textures };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
-        response_function: () =>
-          meshCellsCommonStyle.mutateMeshCellsStyle(id, {
+        response_function: async () => {
+          const mutateResult = await meshCellsCommonStyle.mutateMeshCellsStyle(id, {
             coloring: { textures },
-          }),
+          });
+          return mutateResult;
+        },
       },
     );
+    return result;
   }
 
   return {

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

@@ -49,11 +49,38 @@ function isMeshCellsVertexAttributeValid({
   );
 }
 
+interface UseMeshCellsVertexAttributeStyleReturn {
+  meshCellsVertexAttributeName: (id: string) => string | undefined;
+  meshCellsVertexAttributeItem: (id: string) => number;
+  meshCellsVertexAttributeRange: (id: string) => [number | undefined, number | undefined];
+  meshCellsVertexAttributeColorMap: (id: string) => string | undefined;
+  meshCellsVertexAttributeStoredConfig: (
+    id: string,
+    name: string | undefined,
+    item: number | undefined,
+  ) => AttributeStoredConfig;
+  setMeshCellsVertexAttribute: (id: string, input: AttributeInput) => Promise<unknown>;
+  setMeshCellsVertexAttributeName: (id: string, name: string) => Promise<unknown>;
+  setMeshCellsVertexAttributeItem: (id: string, item: number) => Promise<unknown>;
+  setMeshCellsVertexAttributeRange: (
+    id: string,
+    minimum: number,
+    maximum: number,
+  ) => Promise<unknown>;
+  setMeshCellsVertexAttributeColorMap: (
+    id: string,
+    colorMap: string | undefined,
+  ) => Promise<unknown>;
+  meshCellsVertexAttributeNoDataColor: (id: string) => unknown;
+  setMeshCellsVertexAttributeNoDataColor: (id: string, no_data_color: unknown) => Promise<unknown>;
+}
+
 // oxlint-disable-next-line max-lines-per-function
-function useMeshCellsVertexAttributeStyle() {
+function useMeshCellsVertexAttributeStyle(): UseMeshCellsVertexAttributeStyleReturn {
   const viewerStore = useViewerStore();
   const meshCellsCommonStyle = useMeshCellsCommonStyle();
   function meshCellsVertexAttribute(id: string): AttributeState {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring.vertex shape is defined by the data style schema.
     return meshCellsCommonStyle.meshCellsColoring(id).vertex as AttributeState;
   }
   function meshCellsVertexAttributeStoredConfig(
@@ -62,14 +89,10 @@ function useMeshCellsVertexAttributeStyle() {
     item: number | undefined,
   ): AttributeStoredConfig {
     const { storedConfigs } = meshCellsVertexAttribute(id);
-    if (
-      storedConfigs &&
-      name !== undefined &&
-      name in storedConfigs &&
-      item !== undefined &&
-      item in storedConfigs[name]!
-    ) {
-      return storedConfigs[name]![item]!;
+    const nameConfig = name === undefined ? undefined : storedConfigs?.[name];
+    const itemConfig = item === undefined ? undefined : nameConfig?.[item];
+    if (itemConfig !== undefined) {
+      return itemConfig;
     }
     return {
       minimum: undefined,
@@ -78,35 +101,41 @@ function useMeshCellsVertexAttributeStyle() {
       no_data_color: DEFAULT_NO_DATA_COLOR,
     };
   }
-  function mutateMeshCellsVertexStyle(id: string, values: Record<string, unknown>) {
-    return meshCellsCommonStyle.mutateMeshCellsStyle(id, {
+  async function mutateMeshCellsVertexStyle(
+    id: string,
+    values: Record<string, unknown>,
+  ): Promise<string> {
+    const result = await meshCellsCommonStyle.mutateMeshCellsStyle(id, {
       coloring: {
         vertex: values,
       },
     });
+    return result;
   }
-  function setMeshCellsVertexAttributeStoredConfig(
+  async function setMeshCellsVertexAttributeStoredConfig(
     id: string,
     name: string | undefined,
     item: number | undefined,
     config: Partial<AttributeStoredConfig>,
-  ) {
-    return mutateMeshCellsVertexStyle(id, {
+  ): Promise<string> {
+    const result = await mutateMeshCellsVertexStyle(id, {
       storedConfigs: {
-        [name as string]: {
+        [name ?? ""]: {
           lastItem: item,
-          [item as number]: config,
+          [item ?? 0]: config,
         },
       },
     });
+    return result;
   }
   function meshCellsVertexAttributeName(id: string): string | undefined {
     return meshCellsVertexAttribute(id).name;
   }
   function meshCellsVertexAttributeLastItem(id: string, name: string | undefined): number {
     const { storedConfigs } = meshCellsVertexAttribute(id);
-    if (storedConfigs && name !== undefined && name in storedConfigs) {
-      return storedConfigs[name]!.lastItem;
+    const nameConfig = name === undefined ? undefined : storedConfigs?.[name];
+    if (nameConfig !== undefined) {
+      return nameConfig.lastItem;
     }
     return 0;
   }
@@ -114,7 +143,7 @@ function useMeshCellsVertexAttributeStyle() {
     const { item, name } = meshCellsVertexAttribute(id);
     return item ?? meshCellsVertexAttributeLastItem(id, name);
   }
-  function setMeshCellsVertexAttribute(
+  async function setMeshCellsVertexAttribute(
     id: string,
     {
       name,
@@ -124,18 +153,18 @@ function useMeshCellsVertexAttributeStyle() {
       colorMap,
       no_data_color = DEFAULT_NO_DATA_COLOR,
     }: AttributeInput,
-  ) {
-    mutateMeshCellsVertexStyle(id, {
+  ): Promise<unknown> {
+    await mutateMeshCellsVertexStyle(id, {
       name,
       item,
     });
-    setMeshCellsVertexAttributeStoredConfig(id, name, item, {
+    await setMeshCellsVertexAttributeStoredConfig(id, name, item, {
       minimum,
       maximum,
       colorMap,
       no_data_color,
     });
-    const points = getRGBPointsFromPreset(colorMap as string);
+    const points = getRGBPointsFromPreset(colorMap ?? "");
     const schema = meshCellsVertexAttributeSchemas.attribute;
     const params = {
       id,
@@ -151,7 +180,7 @@ function useMeshCellsVertexAttributeStyle() {
       params,
     });
   }
-  function applyVertexAttribute(id: string) {
+  async function applyVertexAttribute(id: string): Promise<unknown> {
     const name = meshCellsVertexAttributeName(id);
     const item = meshCellsVertexAttributeItem(id);
     const storedConfig = meshCellsVertexAttributeStoredConfig(id, name, item);
@@ -164,19 +193,21 @@ function useMeshCellsVertexAttributeStyle() {
       no_data_color: storedConfig.no_data_color,
     };
     if (isMeshCellsVertexAttributeValid(attribute)) {
-      return setMeshCellsVertexAttribute(id, attribute);
+      const result = await setMeshCellsVertexAttribute(id, attribute);
+      return result;
     }
+    return undefined;
   }
-  function setMeshCellsVertexAttributeName(id: string, name: string) {
+  async function setMeshCellsVertexAttributeName(id: string, name: string): Promise<unknown> {
     const item = meshCellsVertexAttributeLastItem(id, name);
-    mutateMeshCellsVertexStyle(id, {
+    await mutateMeshCellsVertexStyle(id, {
       name,
       item,
     });
     return applyVertexAttribute(id);
   }
-  function setMeshCellsVertexAttributeItem(id: string, item: number) {
-    mutateMeshCellsVertexStyle(id, {
+  async function setMeshCellsVertexAttributeItem(id: string, item: number): Promise<unknown> {
+    await mutateMeshCellsVertexStyle(id, {
       item,
     });
     return applyVertexAttribute(id);
@@ -187,10 +218,14 @@ function useMeshCellsVertexAttributeStyle() {
     const storedConfig = meshCellsVertexAttributeStoredConfig(id, name, item);
     return [storedConfig.minimum, storedConfig.maximum];
   }
-  function setMeshCellsVertexAttributeRange(id: string, minimum: number, maximum: number) {
+  async function setMeshCellsVertexAttributeRange(
+    id: string,
+    minimum: number,
+    maximum: number,
+  ): Promise<unknown> {
     const name = meshCellsVertexAttributeName(id);
     const item = meshCellsVertexAttributeItem(id);
-    setMeshCellsVertexAttributeStoredConfig(id, name, item, {
+    await setMeshCellsVertexAttributeStoredConfig(id, name, item, {
       minimum,
       maximum,
     });
@@ -202,10 +237,13 @@ function useMeshCellsVertexAttributeStyle() {
     const storedConfig = meshCellsVertexAttributeStoredConfig(id, name, item);
     return storedConfig.colorMap;
   }
-  function setMeshCellsVertexAttributeColorMap(id: string, colorMap: string | undefined) {
+  async function setMeshCellsVertexAttributeColorMap(
+    id: string,
+    colorMap: string | undefined,
+  ): Promise<unknown> {
     const name = meshCellsVertexAttributeName(id);
     const item = meshCellsVertexAttributeItem(id);
-    setMeshCellsVertexAttributeStoredConfig(id, name, item, {
+    await setMeshCellsVertexAttributeStoredConfig(id, name, item, {
       colorMap,
     });
     return applyVertexAttribute(id);
@@ -216,7 +254,10 @@ function useMeshCellsVertexAttributeStyle() {
     const storedConfig = meshCellsVertexAttributeStoredConfig(id, name, item);
     return storedConfig.no_data_color;
   }
-  async function setMeshCellsVertexAttributeNoDataColor(id: string, no_data_color: unknown) {
+  async function setMeshCellsVertexAttributeNoDataColor(
+    id: string,
+    no_data_color: unknown,
+  ): Promise<unknown> {
     const name = meshCellsVertexAttributeName(id);
     const item = meshCellsVertexAttributeItem(id);
     const storedConfig = meshCellsVertexAttributeStoredConfig(id, name, item);

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

@@ -8,24 +8,35 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const schema = viewer_schemas.opengeodeweb_viewer.mesh.cells.visibility;
 
-export function useMeshCellsVisibilityStyle() {
+export function useMeshCellsVisibilityStyle(): {
+  meshCellsVisibility: (id: string) => boolean | undefined;
+  setMeshCellsVisibility: (id: string, visibility: boolean | undefined) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const meshCellsCommonStyle = useMeshCellsCommonStyle();
 
   function meshCellsVisibility(id: string): boolean | undefined {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- visibility is defined as boolean in the data style schema.
     return meshCellsCommonStyle.meshCellsStyle(id).visibility as boolean | undefined;
   }
-  function setMeshCellsVisibility(id: string, visibility: boolean | undefined) {
+  async function setMeshCellsVisibility(
+    id: string,
+    visibility: boolean | undefined,
+  ): Promise<unknown> {
     const params = { id, visibility };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
-        response_function: () => meshCellsCommonStyle.mutateMeshCellsStyle(id, { visibility }),
+        response_function: async () => {
+          const mutateResult = await meshCellsCommonStyle.mutateMeshCellsStyle(id, { visibility });
+          return mutateResult;
+        },
       },
     );
+    return result;
   }
 
   return {

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

@@ -8,27 +8,33 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const schema = viewer_schemas.opengeodeweb_viewer.mesh.edges.color;
 
-export function useMeshEdgesColorStyle() {
+export function useMeshEdgesColorStyle(): {
+  meshEdgesColor: (id: string) => unknown;
+  setMeshEdgesColor: (id: string, color: unknown) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
 
   function meshEdgesColor(id: string): unknown {
     return meshEdgesCommonStyle.meshEdgesColoring(id).constant;
   }
-  function setMeshEdgesColor(id: string, color: unknown) {
+  async function setMeshEdgesColor(id: string, color: unknown): Promise<unknown> {
     const params = { id, color };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
-        response_function: () =>
-          meshEdgesCommonStyle.mutateMeshEdgesColoring(id, {
+        response_function: async () => {
+          const mutateResult = await meshEdgesCommonStyle.mutateMeshEdgesColoring(id, {
             constant: color,
-          }),
+          });
+          return mutateResult;
+        },
       },
     );
+    return result;
   }
 
   return {

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

@@ -1,27 +1,35 @@
 import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
 import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
 
-export function useMeshEdgesCommonStyle() {
+export function useMeshEdgesCommonStyle(): {
+  meshEdgesStyle: (id: string) => StyleValues;
+  meshEdgesColoring: (id: string) => StyleValues;
+  mutateMeshEdgesStyle: (id: string, values: StyleValues) => Promise<string>;
+  mutateMeshEdgesColoring: (id: string, values: StyleValues) => Promise<string>;
+} {
   const dataStyleState = useDataStyleState();
 
-  function mutateMeshEdgesStyle(id: string, values: StyleValues) {
-    return dataStyleState.mutateStyle(id, {
+  async function mutateMeshEdgesStyle(id: string, values: StyleValues): Promise<string> {
+    const result = await dataStyleState.mutateStyle(id, {
       edges: values,
     });
+    return result;
   }
 
   function meshEdgesStyle(id: string): StyleValues {
-    return dataStyleState.getStyle(id).edges as StyleValues;
+    return dataStyleState.getStyle(id).edges ?? {};
   }
 
   function meshEdgesColoring(id: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring shape is defined by the data style schema.
     return meshEdgesStyle(id).coloring as StyleValues;
   }
 
-  function mutateMeshEdgesColoring(id: string, values: StyleValues) {
-    return mutateMeshEdgesStyle(id, {
+  async function mutateMeshEdgesColoring(id: string, values: StyleValues): Promise<string> {
+    const result = await mutateMeshEdgesStyle(id, {
       coloring: values,
     });
+    return result;
   }
 
   return {