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

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

@@ -7,24 +7,35 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const schema = viewer_schemas.opengeodeweb_viewer.mesh.edges.visibility;
 
-export function useMeshEdgesVisibilityStyle() {
+export function useMeshEdgesVisibilityStyle(): {
+  meshEdgesVisibility: (id: string) => boolean | undefined;
+  setMeshEdgesVisibility: (id: string, visibility: boolean | undefined) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
 
   function meshEdgesVisibility(id: string): boolean | undefined {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- visibility is defined as boolean in the data style schema.
     return meshEdgesCommonStyle.meshEdgesStyle(id).visibility as boolean | undefined;
   }
-  function setMeshEdgesVisibility(id: string, visibility: boolean | undefined) {
+  async function setMeshEdgesVisibility(
+    id: string,
+    visibility: boolean | undefined,
+  ): Promise<unknown> {
     const params = { id, visibility };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
-        response_function: () => meshEdgesCommonStyle.mutateMeshEdgesStyle(id, { visibility }),
+        response_function: async () => {
+          const mutateResult = await meshEdgesCommonStyle.mutateMeshEdgesStyle(id, { visibility });
+          return mutateResult;
+        },
       },
     );
+    return result;
   }
 
   return {

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

@@ -7,24 +7,32 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const schema = viewer_schemas.opengeodeweb_viewer.mesh.edges.width;
 
-export function useMeshEdgesWidthStyle() {
+export function useMeshEdgesWidthStyle(): {
+  meshEdgesWidth: (id: string) => number | undefined;
+  setMeshEdgesWidth: (id: string, width: number | undefined) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
 
   function meshEdgesWidth(id: string): number | undefined {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- width is defined as number in the data style schema.
     return meshEdgesCommonStyle.meshEdgesStyle(id).width as number | undefined;
   }
-  function setMeshEdgesWidth(id: string, width: number | undefined) {
+  async function setMeshEdgesWidth(id: string, width: number | undefined): Promise<unknown> {
     const params = { id, width };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
-        response_function: () => meshEdgesCommonStyle.mutateMeshEdgesStyle(id, { width }),
+        response_function: async () => {
+          const mutateResult = await meshEdgesCommonStyle.mutateMeshEdgesStyle(id, { width });
+          return mutateResult;
+        },
       },
     );
+    return result;
   }
 
   return {

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

@@ -16,7 +16,17 @@ import { useMeshPolyhedraStyle } from "./polyhedra";
 const meshSchemas = viewer_schemas.opengeodeweb_viewer.mesh;
 
 // oxlint-disable-next-line max-lines-per-function
-export function useMeshStyle() {
+export function useMeshStyle(): {
+  meshVisibility: (id: string) => boolean | undefined;
+  setMeshVisibility: (id: string, visibility: boolean | undefined) => Promise<unknown>;
+  meshColor: (id: string) => unknown;
+  setMeshColor: (id: string, color: unknown) => Promise<unknown>;
+  applyMeshStyle: (id: string) => Promise<unknown[]>;
+} & ReturnType<typeof useMeshPointsStyle> &
+  ReturnType<typeof useMeshEdgesStyle> &
+  ReturnType<typeof useMeshCellsStyle> &
+  ReturnType<typeof useMeshPolygonsStyle> &
+  ReturnType<typeof useMeshPolyhedraStyle> {
   const hybridViewerStore = useHybridViewerStore();
   const viewerStore = useViewerStore();
   const dataStyleState = useDataStyleState();
@@ -29,47 +39,55 @@ export function useMeshStyle() {
   function meshVisibility(id: string): boolean | undefined {
     return dataStyleState.getStyle(id).visibility;
   }
-  function setMeshVisibility(id: string, visibility: boolean | undefined) {
+  async function setMeshVisibility(id: string, visibility: boolean | undefined): Promise<unknown> {
     const schema = meshSchemas.visibility;
     const params = { id, visibility };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
         response_function: async () => {
-          await hybridViewerStore.setVisibility(id, visibility as boolean);
-          return dataStyleState.mutateStyle(id, { visibility });
+          if (visibility !== undefined) {
+            hybridViewerStore.setVisibility(id, visibility);
+          }
+          const mutatedId = await dataStyleState.mutateStyle(id, { visibility });
+          return mutatedId;
         },
       },
     );
+    return result;
   }
 
   function meshColor(id: string): unknown {
     return dataStyleState.getStyle(id).color;
   }
 
-  function setMeshColor(id: string, color: unknown) {
+  async function setMeshColor(id: string, color: unknown): Promise<unknown> {
     const schema = meshSchemas.color;
     const params = { id, color };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
-        response_function: () => dataStyleState.mutateStyle(id, { color }),
+        response_function: async () => {
+          const mutatedId = await dataStyleState.mutateStyle(id, { color });
+          return mutatedId;
+        },
       },
     );
+    return result;
   }
 
-  function applyMeshStyle(id: string) {
+  async function applyMeshStyle(id: string): Promise<unknown[]> {
     const style = dataStyleState.getStyle(id);
     const promise_array: unknown[] = [];
     for (const [key, value] of Object.entries(style)) {
       if (key === "visibility") {
-        promise_array.push(setMeshVisibility(id, value as boolean | undefined));
+        promise_array.push(setMeshVisibility(id, style.visibility));
       } else if (key === "color") {
         promise_array.push(setMeshColor(id, value));
       } else if (key === "points") {
@@ -96,7 +114,8 @@ export function useMeshStyle() {
         throw new Error(`Unknown mesh key: ${key}`);
       }
     }
-    return Promise.all(promise_array);
+    const results = await Promise.all(promise_array);
+    return results;
   }
 
   return {

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

@@ -8,27 +8,33 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const schema = viewer_schemas.opengeodeweb_viewer.mesh.points.color;
 
-export function useMeshPointsColorStyle() {
+export function useMeshPointsColorStyle(): {
+  meshPointsColor: (id: string) => unknown;
+  setMeshPointsColor: (id: string, color: unknown) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const meshPointsCommonStyle = useMeshPointsCommonStyle();
 
   function meshPointsColor(id: string): unknown {
     return meshPointsCommonStyle.meshPointsColoring(id).constant;
   }
-  function setMeshPointsColor(id: string, color: unknown) {
+  async function setMeshPointsColor(id: string, color: unknown): Promise<unknown> {
     const params = { id, color };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
-        response_function: () =>
-          meshPointsCommonStyle.mutateMeshPointsColoring(id, {
+        response_function: async () => {
+          const mutateResult = await meshPointsCommonStyle.mutateMeshPointsColoring(id, {
             constant: color,
-          }),
+          });
+          return mutateResult;
+        },
       },
     );
+    return result;
   }
 
   return {

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

@@ -1,31 +1,44 @@
 import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
 import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
 
-export function useMeshPointsCommonStyle() {
+export function useMeshPointsCommonStyle(): {
+  meshPointsStyle: (id: string) => StyleValues;
+  meshPointsColoring: (id: string) => StyleValues;
+  mutateMeshPointsColoring: (id: string, values: StyleValues) => Promise<string>;
+  mutateMeshPointsStyle: (id: string, values: StyleValues) => Promise<string>;
+  mutateMeshPointsVisibility: (response: { id: string; visibility: boolean }) => Promise<string>;
+} {
   const dataStyleState = useDataStyleState();
 
-  function mutateMeshPointsStyle(id: string, values: StyleValues) {
-    return dataStyleState.mutateStyle(id, {
+  async function mutateMeshPointsStyle(id: string, values: StyleValues): Promise<string> {
+    const result = await dataStyleState.mutateStyle(id, {
       points: values,
     });
+    return result;
   }
 
-  function mutateMeshPointsVisibility(response: { id: string; visibility: boolean }) {
-    return mutateMeshPointsStyle(response.id, { visibility: response.visibility });
+  async function mutateMeshPointsVisibility(response: {
+    id: string;
+    visibility: boolean;
+  }): Promise<string> {
+    const result = await mutateMeshPointsStyle(response.id, { visibility: response.visibility });
+    return result;
   }
 
   function meshPointsStyle(id: string): StyleValues {
-    return dataStyleState.getStyle(id).points as StyleValues;
+    return dataStyleState.getStyle(id).points ?? {};
   }
 
   function meshPointsColoring(id: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring shape is defined by the data style schema.
     return meshPointsStyle(id).coloring as StyleValues;
   }
 
-  function mutateMeshPointsColoring(id: string, values: StyleValues) {
-    return mutateMeshPointsStyle(id, {
+  async function mutateMeshPointsColoring(id: string, values: StyleValues): Promise<string> {
+    const result = await mutateMeshPointsStyle(id, {
       coloring: values,
     });
+    return result;
   }
 
   return {

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

@@ -2,6 +2,7 @@
 
 // Local imports
 import { isMeshPointsVertexAttributeValid, useMeshPointsVertexAttributeStyle } from "./vertex";
+import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
 import { useMeshPointsColorStyle } from "./color";
 import { useMeshPointsCommonStyle } from "./common";
 import { useMeshPointsSizeStyle } from "./size";
@@ -9,74 +10,124 @@ import { useMeshPointsVisibilityStyle } from "./visibility";
 
 // Local constants
 
-function useMeshPointsColoringStyle() {
+interface MeshPointsActiveColoringDeps {
+  readonly commonStyle: ReturnType<typeof useMeshPointsCommonStyle>;
+  readonly colorStyle: ReturnType<typeof useMeshPointsColorStyle>;
+  readonly vertexAttributeStyle: ReturnType<typeof useMeshPointsVertexAttributeStyle>;
+}
+
+function handleMeshPointsVertexColoring(
+  id: string,
+  vertexAttributeStyle: ReturnType<typeof useMeshPointsVertexAttributeStyle>,
+): Promise<unknown> | undefined {
+  const name = vertexAttributeStyle.meshPointsVertexAttributeName(id);
+  const item = vertexAttributeStyle.meshPointsVertexAttributeItem(id);
+  const [minimum, maximum] = vertexAttributeStyle.meshPointsVertexAttributeRange(id);
+  const colorMap = vertexAttributeStyle.meshPointsVertexAttributeColorMap(id);
+  const vertex_attribute = { name, item, minimum, maximum, colorMap };
+  if (!isMeshPointsVertexAttributeValid(vertex_attribute)) {
+    return undefined;
+  }
+  return vertexAttributeStyle.setMeshPointsVertexAttribute(id, vertex_attribute);
+}
+
+async function setMeshPointsActiveColoring(
+  id: string,
+  type: string | undefined,
+  deps: MeshPointsActiveColoringDeps,
+): Promise<unknown> {
+  await deps.commonStyle.mutateMeshPointsStyle(id, {
+    coloring: { active: type },
+  });
+  if (type === "constant") {
+    const result = await deps.colorStyle.setMeshPointsColor(
+      id,
+      deps.colorStyle.meshPointsColor(id),
+    );
+    return result;
+  }
+  if (type === "vertex") {
+    const result = await handleMeshPointsVertexColoring(id, deps.vertexAttributeStyle);
+    return result;
+  }
+  throw new Error(`Unknown mesh points coloring type: ${type}`);
+}
+
+async function applyMeshPointsStyle(
+  id: string,
+  visibilityStyle: ReturnType<typeof useMeshPointsVisibilityStyle>,
+  sizeStyle: ReturnType<typeof useMeshPointsSizeStyle>,
+  activeColoringType: string | undefined,
+  deps: MeshPointsActiveColoringDeps,
+): Promise<unknown[]> {
+  const result = await Promise.all([
+    visibilityStyle.setMeshPointsVisibility(id, visibilityStyle.meshPointsVisibility(id)),
+    sizeStyle.setMeshPointsSize(id, sizeStyle.meshPointsSize(id)),
+    setMeshPointsActiveColoring(id, activeColoringType, deps),
+  ]);
+  return result;
+}
+
+type UseMeshPointsStyleReturn = ReturnType<typeof useMeshPointsCommonStyle> & {
+  meshPointsColoring: (id: string) => StyleValues;
+  meshPointsActiveColoring: (id: string) => string | undefined;
+  setMeshPointsActiveColoring: (id: string, type: string | undefined) => Promise<unknown>;
+  applyMeshPointsStyle: (id: string) => Promise<unknown[]>;
+} & ReturnType<typeof useMeshPointsVisibilityStyle> &
+  ReturnType<typeof useMeshPointsColorStyle> &
+  ReturnType<typeof useMeshPointsSizeStyle> &
+  ReturnType<typeof useMeshPointsVertexAttributeStyle>;
+
+export function useMeshPointsStyle(): UseMeshPointsStyleReturn {
   const meshPointsCommonStyle = useMeshPointsCommonStyle();
+  const meshPointsVisibility = useMeshPointsVisibilityStyle();
   const meshPointsColorStyle = useMeshPointsColorStyle();
+  const meshPointsSizeStyle = useMeshPointsSizeStyle();
   const meshPointsVertexAttributeStyle = useMeshPointsVertexAttributeStyle();
 
-  function meshPointsColoring(id: string) {
+  const activeColoringDeps: MeshPointsActiveColoringDeps = {
+    commonStyle: meshPointsCommonStyle,
+    colorStyle: meshPointsColorStyle,
+    vertexAttributeStyle: meshPointsVertexAttributeStyle,
+  };
+
+  function meshPointsColoring(id: string): StyleValues {
     return meshPointsCommonStyle.meshPointsColoring(id);
   }
 
   function meshPointsActiveColoring(id: string): string | undefined {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring.active is defined as string in the data style schema.
     return meshPointsColoring(id).active as string | undefined;
   }
 
-  async function setMeshPointsActiveColoring(id: string, type: string | undefined) {
-    await meshPointsCommonStyle.mutateMeshPointsStyle(id, {
-      coloring: { active: type },
-    });
-    if (type === "constant") {
-      return meshPointsColorStyle.setMeshPointsColor(id, meshPointsColorStyle.meshPointsColor(id));
-    }
-    if (type === "vertex") {
-      const name = meshPointsVertexAttributeStyle.meshPointsVertexAttributeName(id);
-      const item = meshPointsVertexAttributeStyle.meshPointsVertexAttributeItem(id);
-      const [minimum, maximum] = meshPointsVertexAttributeStyle.meshPointsVertexAttributeRange(id);
-      const colorMap = meshPointsVertexAttributeStyle.meshPointsVertexAttributeColorMap(id);
-      const vertex_attribute = { name, item, minimum, maximum, colorMap };
-      if (!isMeshPointsVertexAttributeValid(vertex_attribute)) {
-        return;
-      }
-      return meshPointsVertexAttributeStyle.setMeshPointsVertexAttribute(id, vertex_attribute);
-    }
-    throw new Error(`Unknown mesh points coloring type: ${type}`);
+  async function boundSetMeshPointsActiveColoring(
+    id: string,
+    type: string | undefined,
+  ): Promise<unknown> {
+    const result = await setMeshPointsActiveColoring(id, type, activeColoringDeps);
+    return result;
   }
 
-  return {
-    meshPointsColoring,
-    meshPointsActiveColoring,
-    setMeshPointsActiveColoring,
-    ...meshPointsColorStyle,
-    ...meshPointsVertexAttributeStyle,
-  };
-}
-
-export function useMeshPointsStyle() {
-  const meshPointsCommonStyle = useMeshPointsCommonStyle();
-  const meshPointsVisibility = useMeshPointsVisibilityStyle();
-  const meshPointsSizeStyle = useMeshPointsSizeStyle();
-  const meshPointsColoringStyle = useMeshPointsColoringStyle();
-
-  function applyMeshPointsStyle(id: string) {
-    return Promise.all([
-      meshPointsVisibility.setMeshPointsVisibility(
-        id,
-        meshPointsVisibility.meshPointsVisibility(id),
-      ),
-      meshPointsSizeStyle.setMeshPointsSize(id, meshPointsSizeStyle.meshPointsSize(id)),
-      meshPointsColoringStyle.setMeshPointsActiveColoring(
-        id,
-        meshPointsColoringStyle.meshPointsActiveColoring(id),
-      ),
-    ]);
+  async function boundApplyMeshPointsStyle(id: string): Promise<unknown[]> {
+    const result = await applyMeshPointsStyle(
+      id,
+      meshPointsVisibility,
+      meshPointsSizeStyle,
+      meshPointsActiveColoring(id),
+      activeColoringDeps,
+    );
+    return result;
   }
 
   return {
     ...meshPointsCommonStyle,
-    ...meshPointsColoringStyle,
-    applyMeshPointsStyle,
+    meshPointsColoring,
+    meshPointsActiveColoring,
+    setMeshPointsActiveColoring: boundSetMeshPointsActiveColoring,
+    applyMeshPointsStyle: boundApplyMeshPointsStyle,
     ...meshPointsVisibility,
+    ...meshPointsColorStyle,
     ...meshPointsSizeStyle,
+    ...meshPointsVertexAttributeStyle,
   };
 }

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

@@ -8,24 +8,32 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const schema = viewer_schemas.opengeodeweb_viewer.mesh.points.size;
 
-export function useMeshPointsSizeStyle() {
+export function useMeshPointsSizeStyle(): {
+  meshPointsSize: (id: string) => number | undefined;
+  setMeshPointsSize: (id: string, size: number | undefined) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const meshPointsCommonStyle = useMeshPointsCommonStyle();
 
   function meshPointsSize(id: string): number | undefined {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- size is defined as number in the data style schema.
     return meshPointsCommonStyle.meshPointsStyle(id).size as number | undefined;
   }
-  function setMeshPointsSize(id: string, size: number | undefined) {
+  async function setMeshPointsSize(id: string, size: number | undefined): Promise<unknown> {
     const params = { id, size };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
-        response_function: () => meshPointsCommonStyle.mutateMeshPointsStyle(id, { size }),
+        response_function: async () => {
+          const mutateResult = await meshPointsCommonStyle.mutateMeshPointsStyle(id, { size });
+          return mutateResult;
+        },
       },
     );
+    return result;
   }
 
   return {