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

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

@@ -19,12 +19,19 @@ interface AttributeGroup {
   lines_ids: string[];
 }
 
-async function setModelLinesDefaultStyle(_id: string) {
+async function setModelLinesDefaultStyle(_id: string): Promise<void> {
   // Placeholder
 }
 
 // oxlint-disable-next-line max-lines-per-function
-export function useModelLinesStyle() {
+export function useModelLinesStyle(): ReturnType<typeof useModelLinesCommonStyle> &
+  ReturnType<typeof useModelLinesVisibility> &
+  ReturnType<typeof useModelLinesColor> &
+  ReturnType<typeof useModelLinesVertexAttribute> &
+  ReturnType<typeof useModelLinesEdgeAttribute> & {
+    applyModelLinesStyle: (modelId: string) => Promise<void>;
+    setModelLinesDefaultStyle: (id: string) => Promise<void>;
+  } {
   const dataStore = useDataStore();
   const modelCommonStyle = useModelLinesCommonStyle();
   const modelVisibilityStyle = useModelLinesVisibility();
@@ -32,30 +39,37 @@ export function useModelLinesStyle() {
   const modelLinesVertexAttribute = useModelLinesVertexAttribute();
   const modelLinesEdgeAttribute = useModelLinesEdgeAttribute();
 
-  function applyModelLinesVisibilityStyle(modelId: string, lines_ids: string[]) {
+  async function applyModelLinesVisibilityStyle(
+    modelId: string,
+    lines_ids: string[],
+  ): Promise<void> {
     const visibilityGroups: Record<string, string[]> = {};
     for (const line_id of lines_ids) {
       const style = modelCommonStyle.modelLineStyle(modelId, line_id);
       const visibility = String(style.visibility);
-      if (!visibilityGroups[visibility]) {
-        visibilityGroups[visibility] = [];
-      }
+      visibilityGroups[visibility] ??= [];
       visibilityGroups[visibility].push(line_id);
     }
-    return Promise.all(
-      Object.entries(visibilityGroups).map(([visibility, ids]) =>
-        modelVisibilityStyle.setModelLinesVisibility(modelId, ids, visibility === "true"),
-      ),
+    await Promise.all(
+      Object.entries(visibilityGroups).map(async ([visibility, ids]) => {
+        const result = await modelVisibilityStyle.setModelLinesVisibility(
+          modelId,
+          ids,
+          visibility === "true",
+        );
+        return result;
+      }),
     );
   }
 
-  function applyModelLinesColoringStyle(modelId: string, lines_ids: string[]) {
+  async function applyModelLinesColoringStyle(
+    modelId: string,
+    lines_ids: string[],
+  ): Promise<unknown[]> {
     const activeColoringGroups: Record<string, string[]> = {};
     for (const line_id of lines_ids) {
       const activeColoring = String(modelColorStyle.modelLineActiveColoring(modelId, line_id));
-      if (!activeColoringGroups[activeColoring]) {
-        activeColoringGroups[activeColoring] = [];
-      }
+      activeColoringGroups[activeColoring] ??= [];
       activeColoringGroups[activeColoring].push(line_id);
     }
 
@@ -67,15 +81,19 @@ export function useModelLinesStyle() {
         for (const line_id of type_lines_ids) {
           const color = modelColorStyle.modelLineColor(modelId, line_id);
           const color_key = JSON.stringify(color);
-          if (!colorGroups[color_key]) {
-            colorGroups[color_key] = { color, lines_ids: [] };
-          }
+          colorGroups[color_key] ??= { color, lines_ids: [] };
           colorGroups[color_key].lines_ids.push(line_id);
         }
         coloringPromises.push(
-          ...Object.values(colorGroups).map(({ color, lines_ids: ids }) =>
-            modelColorStyle.setModelLinesColor(modelId, ids, color, "constant"),
-          ),
+          ...Object.values(colorGroups).map(async ({ color, lines_ids: ids }) => {
+            const result = await modelColorStyle.setModelLinesColor(
+              modelId,
+              ids,
+              color,
+              "constant",
+            );
+            return result;
+          }),
         );
       } else if (type === "random") {
         coloringPromises.push(
@@ -99,28 +117,32 @@ export function useModelLinesStyle() {
             continue;
           }
           const key = `${name}_${item}_${colorMap}_${minimum}_${maximum}`;
-          if (!vertexGroups[key]) {
-            vertexGroups[key] = {
-              name,
-              item,
-              minimum,
-              maximum,
-              colorMap,
-              lines_ids: [],
-            };
-          }
+          vertexGroups[key] ??= {
+            name,
+            item,
+            minimum,
+            maximum,
+            colorMap,
+            lines_ids: [],
+          };
           vertexGroups[key].lines_ids.push(line_id);
         }
         coloringPromises.push(
           ...Object.values(vertexGroups).map(
-            ({ name, item, minimum, maximum, colorMap, lines_ids: ids }) =>
-              modelLinesVertexAttribute.setModelLinesVertexAttribute(modelId, ids, {
-                name,
-                item,
-                minimum,
-                maximum,
-                colorMap,
-              }),
+            async ({ name, item, minimum, maximum, colorMap, lines_ids: ids }) => {
+              const result = await modelLinesVertexAttribute.setModelLinesVertexAttribute(
+                modelId,
+                ids,
+                {
+                  name,
+                  item,
+                  minimum,
+                  maximum,
+                  colorMap,
+                },
+              );
+              return result;
+            },
           ),
         );
       } else if (type === "edge") {
@@ -141,41 +163,46 @@ export function useModelLinesStyle() {
             continue;
           }
           const key = `${name}_${item}_${colorMap}_${minimum}_${maximum}`;
-          if (!edgeGroups[key]) {
-            edgeGroups[key] = {
-              name,
-              item,
-              minimum,
-              maximum,
-              colorMap,
-              lines_ids: [],
-            };
-          }
+          edgeGroups[key] ??= {
+            name,
+            item,
+            minimum,
+            maximum,
+            colorMap,
+            lines_ids: [],
+          };
           edgeGroups[key].lines_ids.push(line_id);
         }
         coloringPromises.push(
           ...Object.values(edgeGroups).map(
-            ({ name, item, minimum, maximum, colorMap, lines_ids: ids }) =>
-              modelLinesEdgeAttribute.setModelLinesEdgeAttribute(modelId, ids, {
-                name,
-                item,
-                minimum,
-                maximum,
-                colorMap,
-              }),
+            async ({ name, item, minimum, maximum, colorMap, lines_ids: ids }) => {
+              const result = await modelLinesEdgeAttribute.setModelLinesEdgeAttribute(
+                modelId,
+                ids,
+                {
+                  name,
+                  item,
+                  minimum,
+                  maximum,
+                  colorMap,
+                },
+              );
+              return result;
+            },
           ),
         );
       }
     }
-    return Promise.all(coloringPromises);
+    const results = await Promise.all(coloringPromises);
+    return results;
   }
 
-  async function applyModelLinesStyle(modelId: string) {
+  async function applyModelLinesStyle(modelId: string): Promise<void> {
     const lines_ids = await dataStore.getLinesGeodeIds(modelId);
     if (lines_ids.length === 0) {
       return;
     }
-    return Promise.all([
+    await Promise.all([
       applyModelLinesVisibilityStyle(modelId, lines_ids),
       applyModelLinesColoringStyle(modelId, lines_ids),
     ]);

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

@@ -1,3 +1,4 @@
+// oxlint-disable eslint/max-lines
 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";
@@ -49,12 +50,61 @@ function isModelLinesVertexAttributeValid({
   );
 }
 
+interface UseModelLinesVertexAttributeReturn {
+  modelLinesVertexAttributeName: (modelId: string, lineId?: string) => string | undefined;
+  modelLinesVertexAttributeItem: (modelId: string, lineId?: string) => number;
+  modelLinesVertexAttributeRange: (
+    modelId: string,
+    lineId?: string,
+  ) => [number | undefined, number | undefined];
+  modelLinesVertexAttributeColorMap: (modelId: string, lineId?: string) => string | undefined;
+  modelLinesVertexAttributeStoredConfig: (
+    modelId: string,
+    lineId: string | undefined,
+    name: string | undefined,
+    item: number | undefined,
+  ) => AttributeStoredConfig;
+  setModelLinesVertexAttribute: (
+    modelId: string,
+    lineIds: string[],
+    input: AttributeInput,
+  ) => Promise<unknown>;
+  setModelLinesVertexAttributeName: (
+    modelId: string,
+    lineIds: string[],
+    name: string,
+  ) => Promise<unknown>;
+  setModelLinesVertexAttributeItem: (
+    modelId: string,
+    lineIds: string[],
+    item: number,
+  ) => Promise<unknown>;
+  setModelLinesVertexAttributeRange: (
+    modelId: string,
+    lineIds: string[],
+    minimum: number,
+    maximum: number,
+  ) => Promise<unknown>;
+  setModelLinesVertexAttributeColorMap: (
+    modelId: string,
+    lineIds: string[],
+    colorMap: string | undefined,
+  ) => Promise<unknown>;
+  modelLinesVertexAttributeNoDataColor: (modelId: string, lineId?: string) => unknown;
+  setModelLinesVertexAttributeNoDataColor: (
+    modelId: string,
+    lineIds: string[],
+    no_data_color: unknown,
+  ) => Promise<unknown>;
+}
+
 // oxlint-disable-next-line max-lines-per-function
-function useModelLinesVertexAttribute() {
+function useModelLinesVertexAttribute(): UseModelLinesVertexAttributeReturn {
   const dataStore = useDataStore();
   const modelLinesCommonStyle = useModelLinesCommonStyle();
   const viewerStore = useViewerStore();
   function modelLinesVertexAttribute(modelId: string, lineId?: string): AttributeState {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring.vertex shape is defined by the data style schema.
     return modelLinesCommonStyle.modelLineColoring(modelId, lineId).vertex as AttributeState;
   }
   function modelLinesVertexAttributeStoredConfig(
@@ -64,14 +114,10 @@ function useModelLinesVertexAttribute() {
     item: number | undefined,
   ): AttributeStoredConfig {
     const { storedConfigs } = modelLinesVertexAttribute(modelId, lineId);
-    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,
@@ -80,32 +126,41 @@ function useModelLinesVertexAttribute() {
       no_data_color: DEFAULT_NO_DATA_COLOR,
     };
   }
-  function mutateModelLinesVertexStyle(
+  async function mutateModelLinesVertexStyle(
     modelId: string,
     lineIds: string[],
     values: Record<string, unknown>,
-  ) {
-    if (lineIds.length > 1) {
-      modelLinesCommonStyle.mutateModelLinesTypeColoring(modelId, {
+  ): Promise<void> {
+    const tasks: Promise<void>[] = [
+      modelLinesCommonStyle.mutateModelLinesColoring(modelId, lineIds, {
         vertex: values,
-      });
+      }),
+    ];
+    const totalLineIds = await dataStore.getLinesGeodeIds(modelId);
+    if (lineIds.length === totalLineIds.length) {
+      tasks.push(
+        modelLinesCommonStyle.mutateModelLinesTypeColoring(modelId, {
+          vertex: values,
+        }),
+      );
     }
-    return modelLinesCommonStyle.mutateModelLinesColoring(modelId, lineIds, {
-      vertex: values,
-    });
+    await Promise.all(tasks);
   }
-  function setModelLinesVertexAttributeStoredConfig(
+  async function setModelLinesVertexAttributeStoredConfig(
     modelId: string,
     lineIds: string[],
     name: string | undefined,
     item: number | undefined,
     config: Partial<AttributeStoredConfig>,
-  ) {
-    return mutateModelLinesVertexStyle(modelId, lineIds, {
+  ): Promise<void> {
+    if (name === undefined || item === undefined) {
+      return;
+    }
+    await mutateModelLinesVertexStyle(modelId, lineIds, {
       storedConfigs: {
-        [name as string]: {
+        [name]: {
           lastItem: item,
-          [item as number]: config,
+          [item]: config,
         },
       },
     });
@@ -119,8 +174,9 @@ function useModelLinesVertexAttribute() {
     name: string | undefined,
   ): number {
     const { storedConfigs } = modelLinesVertexAttribute(modelId, lineId);
-    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;
   }
@@ -158,18 +214,18 @@ function useModelLinesVertexAttribute() {
       colorMap,
       no_data_color = DEFAULT_NO_DATA_COLOR,
     }: AttributeInput,
-  ) {
-    mutateModelLinesVertexStyle(modelId, lineIds, {
+  ): Promise<unknown> {
+    await mutateModelLinesVertexStyle(modelId, lineIds, {
       name,
       item,
     });
-    setModelLinesVertexAttributeStoredConfig(modelId, lineIds, name, item, {
+    await setModelLinesVertexAttributeStoredConfig(modelId, lineIds, name, item, {
       minimum,
       maximum,
       colorMap,
       no_data_color,
     });
-    const points = getRGBPointsFromPreset(colorMap as string);
+    const points = getRGBPointsFromPreset(colorMap ?? "");
     const line_viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, lineIds);
     const params = {
       id: modelId,
@@ -186,7 +242,7 @@ function useModelLinesVertexAttribute() {
       params,
     });
   }
-  function applyVertexAttribute(modelId: string, lineIds: string[]) {
+  async function applyVertexAttribute(modelId: string, lineIds: string[]): Promise<void> {
     const name = modelLinesVertexAttributeName(modelId, lineIds[0]);
     const item = modelLinesVertexAttributeItem(modelId, lineIds[0]);
     const storedConfig = modelLinesVertexAttributeStoredConfig(modelId, lineIds[0], name, item);
@@ -199,46 +255,53 @@ function useModelLinesVertexAttribute() {
       no_data_color: storedConfig.no_data_color,
     };
     if (isModelLinesVertexAttributeValid(attribute)) {
-      return setModelLinesVertexAttribute(modelId, lineIds, attribute);
+      await setModelLinesVertexAttribute(modelId, lineIds, attribute);
     }
-    return Promise.resolve();
   }
-  function setModelLinesVertexAttributeName(modelId: string, lineIds: string[], name: string) {
+  async function setModelLinesVertexAttributeName(
+    modelId: string,
+    lineIds: string[],
+    name: string,
+  ): Promise<unknown> {
     const item = modelLinesVertexAttributeLastItem(modelId, lineIds[0], name);
-    mutateModelLinesVertexStyle(modelId, lineIds, {
+    await mutateModelLinesVertexStyle(modelId, lineIds, {
       name,
       item,
     });
     return applyVertexAttribute(modelId, lineIds);
   }
-  function setModelLinesVertexAttributeItem(modelId: string, lineIds: string[], item: number) {
-    mutateModelLinesVertexStyle(modelId, lineIds, {
+  async function setModelLinesVertexAttributeItem(
+    modelId: string,
+    lineIds: string[],
+    item: number,
+  ): Promise<unknown> {
+    await mutateModelLinesVertexStyle(modelId, lineIds, {
       item,
     });
     return applyVertexAttribute(modelId, lineIds);
   }
-  function setModelLinesVertexAttributeRange(
+  async function setModelLinesVertexAttributeRange(
     modelId: string,
     lineIds: string[],
     minimum: number,
     maximum: number,
-  ) {
+  ): Promise<unknown> {
     const name = modelLinesVertexAttributeName(modelId, lineIds[0]);
     const item = modelLinesVertexAttributeItem(modelId, lineIds[0]);
-    setModelLinesVertexAttributeStoredConfig(modelId, lineIds, name, item, {
+    await setModelLinesVertexAttributeStoredConfig(modelId, lineIds, name, item, {
       minimum,
       maximum,
     });
     return applyVertexAttribute(modelId, lineIds);
   }
-  function setModelLinesVertexAttributeColorMap(
+  async function setModelLinesVertexAttributeColorMap(
     modelId: string,
     lineIds: string[],
     colorMap: string | undefined,
-  ) {
+  ): Promise<unknown> {
     const name = modelLinesVertexAttributeName(modelId, lineIds[0]);
     const item = modelLinesVertexAttributeItem(modelId, lineIds[0]);
-    setModelLinesVertexAttributeStoredConfig(modelId, lineIds, name, item, {
+    await setModelLinesVertexAttributeStoredConfig(modelId, lineIds, name, item, {
       colorMap,
     });
     return applyVertexAttribute(modelId, lineIds);
@@ -253,7 +316,7 @@ function useModelLinesVertexAttribute() {
     modelId: string,
     lineIds: string[],
     no_data_color: unknown,
-  ) {
+  ): Promise<unknown> {
     const name = modelLinesVertexAttributeName(modelId, lineIds[0]);
     const item = modelLinesVertexAttributeItem(modelId, lineIds[0]);
     const storedConfig = modelLinesVertexAttributeStoredConfig(modelId, lineIds[0], name, item);

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

@@ -4,7 +4,14 @@ import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schem
 
 const schema = viewer_schemas.opengeodeweb_viewer.model.lines.visibility;
 
-export function useModelLinesVisibility() {
+export function useModelLinesVisibility(): {
+  setModelLinesVisibility: (
+    modelId: string,
+    lines_ids: string[],
+    visibility: boolean | undefined,
+  ) => Promise<unknown>;
+  modelLineVisibility: (id: string, line_id?: string) => unknown;
+} {
   const modelCommonStyle = useModelCommonStyle();
   const modelLinesCommonStyle = useModelLinesCommonStyle();
 
@@ -12,12 +19,18 @@ export function useModelLinesVisibility() {
     return modelLinesCommonStyle.modelLineStyle(id, line_id).visibility;
   }
 
-  function setModelLinesVisibility(
+  async function setModelLinesVisibility(
     modelId: string,
     lines_ids: string[],
     visibility: boolean | undefined,
-  ) {
-    return modelCommonStyle.setModelTypeVisibility(modelId, lines_ids, visibility, schema);
+  ): Promise<unknown> {
+    const result = await modelCommonStyle.setModelTypeVisibility(
+      modelId,
+      lines_ids,
+      visibility,
+      schema,
+    );
+    return result;
   }
 
   return { setModelLinesVisibility, modelLineVisibility };

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

@@ -1,17 +1,21 @@
 import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
 import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
 
-export function useModelPointsCommonStyle() {
+export function useModelPointsCommonStyle(): {
+  modelPointsStyle: (id: string) => StyleValues;
+  mutateModelPointsStyle: (id: string, values: StyleValues) => Promise<unknown>;
+} {
   const dataStyleState = useDataStyleState();
 
-  function mutateModelPointsStyle(id: string, values: StyleValues) {
-    return dataStyleState.mutateStyle(id, {
+  async function mutateModelPointsStyle(id: string, values: StyleValues): Promise<unknown> {
+    const result = await dataStyleState.mutateStyle(id, {
       points: values,
     });
+    return result;
   }
 
   function modelPointsStyle(id: string): StyleValues {
-    return dataStyleState.getStyle(id).points as StyleValues;
+    return dataStyleState.getStyle(id).points ?? {};
   }
 
   return {

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

@@ -3,20 +3,27 @@ import { useModelPointsCommonStyle } from "./common";
 import { useModelPointsSizeStyle } from "./size";
 import { useModelPointsVisibilityStyle } from "./visibility";
 
-export function useModelPointsStyle() {
+export function useModelPointsStyle(): {
+  applyModelPointsStyle: (id: string) => Promise<unknown[]>;
+} & ReturnType<typeof useModelPointsCommonStyle> &
+  ReturnType<typeof useModelPointsVisibilityStyle> &
+  ReturnType<typeof useModelPointsSizeStyle> {
   const modelPointsCommonStyle = useModelPointsCommonStyle();
   const modelPointsVisibilityStyle = useModelPointsVisibilityStyle();
   const modelPointsSizeStyle = useModelPointsSizeStyle();
 
-  function applyModelPointsStyle(id: string) {
+  async function applyModelPointsStyle(id: string): Promise<unknown[]> {
     const style = modelPointsCommonStyle.modelPointsStyle(id);
-    return Promise.all([
+    const result = await Promise.all([
       modelPointsVisibilityStyle.setModelPointsVisibility(
         id,
+        // oxlint-disable-next-line no-unsafe-type-assertion -- points style values are dynamically typed at runtime.
         style.visibility as boolean | undefined,
       ),
+      // oxlint-disable-next-line no-unsafe-type-assertion -- points style values are dynamically typed at runtime.
       modelPointsSizeStyle.setModelPointsSize(id, style.size as number | undefined),
     ]);
+    return result;
   }
 
   return {

package/internal/stores/data_style/model/points/size.ts

@@ -8,25 +8,33 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const schema = viewer_schemas.opengeodeweb_viewer.model.points.size;
 
-export function useModelPointsSizeStyle() {
+export function useModelPointsSizeStyle(): {
+  modelPointsSize: (id: string) => number | undefined;
+  setModelPointsSize: (id: string, size: number | undefined) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const modelPointsCommonStyle = useModelPointsCommonStyle();
 
   function modelPointsSize(id: string): number | undefined {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- points style values are dynamically typed at runtime.
     return modelPointsCommonStyle.modelPointsStyle(id).size as number | undefined;
   }
 
-  function setModelPointsSize(id: string, size: number | undefined) {
+  async function setModelPointsSize(id: string, size: number | undefined): Promise<unknown> {
     const params = { id, size };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
-        response_function: () => modelPointsCommonStyle.mutateModelPointsStyle(id, { size }),
+        response_function: async () => {
+          const mutateResult = await modelPointsCommonStyle.mutateModelPointsStyle(id, { size });
+          return mutateResult;
+        },
       },
     );
+    return result;
   }
 
   return {

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

@@ -8,25 +8,35 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const schema = viewer_schemas.opengeodeweb_viewer.model.points.visibility;
 
-export function useModelPointsVisibilityStyle() {
+export function useModelPointsVisibilityStyle(): {
+  modelPointsVisibility: (id: string) => boolean | undefined;
+  setModelPointsVisibility: (id: string, visibility: boolean | undefined) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const modelPointsCommonStyle = useModelPointsCommonStyle();
 
   function modelPointsVisibility(id: string): boolean | undefined {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- points style values are dynamically typed at runtime.
     return modelPointsCommonStyle.modelPointsStyle(id).visibility as boolean | undefined;
   }
 
-  function setModelPointsVisibility(id: string, visibility: boolean | undefined) {
+  async function setModelPointsVisibility(
+    id: string,
+    visibility: boolean | undefined,
+  ): Promise<unknown> {
     const params = { id, visibility };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       { schema, params },
       {
-        response_function: () =>
-          modelPointsCommonStyle.mutateModelPointsStyle(id, {
+        response_function: async () => {
+          const mutateResult = await modelPointsCommonStyle.mutateModelPointsStyle(id, {
             visibility,
-          }),
+          });
+          return mutateResult;
+        },
       },
     );
+    return result;
   }
 
   return {