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

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

@@ -8,27 +8,37 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const schema = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.visibility;
 
-export function useMeshPolyhedraVisibilityStyle() {
+export function useMeshPolyhedraVisibilityStyle(): {
+  meshPolyhedraVisibility: (id: string) => boolean | undefined;
+  setMeshPolyhedraVisibility: (id: string, visibility: boolean | undefined) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle();
 
   function meshPolyhedraVisibility(id: string): boolean | undefined {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- visibility is defined as boolean in the data style schema.
     return meshPolyhedraCommonStyle.meshPolyhedraStyle(id).visibility as boolean | undefined;
   }
-  function setMeshPolyhedraVisibility(id: string, visibility: boolean | undefined) {
+  async function setMeshPolyhedraVisibility(
+    id: string,
+    visibility: boolean | undefined,
+  ): Promise<unknown> {
     const params = { id, visibility };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
-        response_function: () =>
-          meshPolyhedraCommonStyle.mutateMeshPolyhedraStyle(id, {
+        response_function: async () => {
+          const mutation_result = await meshPolyhedraCommonStyle.mutateMeshPolyhedraStyle(id, {
             visibility,
-          }),
+          });
+          return mutation_result;
+        },
       },
     );
+    return result;
   }
 
   return {

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

@@ -1,24 +1,42 @@
-// 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 {
   isModelBlocksPolyhedronAttributeValid,
   useModelBlocksPolyhedronAttribute,
 } from "./polyhedron";
 import { isModelBlocksVertexAttributeValid, useModelBlocksVertexAttribute } from "./vertex";
+import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
+import { useDataStore } from "@ogw_front/stores/data";
 import { useModelBlocksCommonStyle } from "./common";
 import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 const schema = viewer_schemas.opengeodeweb_viewer.model.blocks.color;
 
-export function useModelBlocksColor() {
+export function useModelBlocksColor(): {
+  modelBlockColoring: (id: string, block_id?: string) => StyleValues;
+  modelBlockColor: (id: string, block_id?: string) => unknown;
+  setModelBlocksColor: (
+    modelId: string,
+    blocks_ids: string[],
+    color: unknown,
+    activeColoring?: string,
+    collectionId?: string,
+  ) => Promise<unknown>;
+  modelBlockActiveColoring: (id: string, block_id?: string) => unknown;
+  setModelBlocksActiveColoring: (
+    modelId: string,
+    blocks_ids: string[],
+    activeColoring: string,
+    collectionId?: string,
+  ) => Promise<void>;
+} {
+  const dataStore = useDataStore();
   const modelCommonStyle = useModelCommonStyle();
   const modelBlocksCommonStyle = useModelBlocksCommonStyle();
   const modelBlocksVertexAttribute = useModelBlocksVertexAttribute();
   const modelBlocksPolyhedronAttribute = useModelBlocksPolyhedronAttribute();
 
   function modelBlockColoring(id: string, block_id?: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring shape is defined by the data style schema.
     return modelBlocksCommonStyle.modelBlockStyle(id, block_id).coloring as StyleValues;
   }
 
@@ -26,13 +44,22 @@ export function useModelBlocksColor() {
     return modelBlockColoring(id, block_id).constant;
   }
 
-  function setModelBlocksColor(
+  async function setModelBlocksColor(
     modelId: string,
     blocks_ids: string[],
     color: unknown,
     activeColoring = "constant",
-  ) {
-    return modelCommonStyle.setModelTypeColor(modelId, blocks_ids, color, schema, activeColoring);
+    collectionId?: string,
+  ): Promise<unknown> {
+    const result = await modelCommonStyle.setModelTypeColor(
+      modelId,
+      blocks_ids,
+      color,
+      schema,
+      activeColoring,
+      collectionId,
+    );
+    return result;
   }
 
   function modelBlockActiveColoring(id: string, block_id?: string): unknown {
@@ -43,9 +70,11 @@ export function useModelBlocksColor() {
     modelId: string,
     blocks_ids: string[],
     activeColoring: string,
-  ) {
-    if (blocks_ids.length > 1) {
-      modelBlocksCommonStyle.mutateModelBlocksTypeColoring(modelId, {
+    collectionId?: string,
+  ): Promise<void> {
+    const totalBlockIds = await dataStore.getBlocksGeodeIds(modelId);
+    if (blocks_ids.length === totalBlockIds.length) {
+      await modelBlocksCommonStyle.mutateModelBlocksTypeColoring(modelId, {
         active: activeColoring,
       });
     }
@@ -54,7 +83,8 @@ export function useModelBlocksColor() {
     });
     if (activeColoring === "constant" || activeColoring === "random") {
       const color = modelBlockColor(modelId, blocks_ids[0]);
-      return setModelBlocksColor(modelId, blocks_ids, color, activeColoring);
+      await setModelBlocksColor(modelId, blocks_ids, color, activeColoring, collectionId);
+      return;
     }
 
     if (activeColoring === "vertex") {
@@ -76,7 +106,7 @@ export function useModelBlocksColor() {
       );
       const attribute = { name, item, minimum, maximum, colorMap };
       if (isModelBlocksVertexAttributeValid(attribute)) {
-        return modelBlocksVertexAttribute.setModelBlocksVertexAttribute(
+        await modelBlocksVertexAttribute.setModelBlocksVertexAttribute(
           modelId,
           blocks_ids,
           attribute,
@@ -101,7 +131,7 @@ export function useModelBlocksColor() {
       );
       const attribute = { name, item, minimum, maximum, colorMap };
       if (isModelBlocksPolyhedronAttributeValid(attribute)) {
-        return modelBlocksPolyhedronAttribute.setModelBlocksPolyhedronAttribute(
+        await modelBlocksPolyhedronAttribute.setModelBlocksPolyhedronAttribute(
           modelId,
           blocks_ids,
           attribute,

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

@@ -3,12 +3,22 @@ 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 useModelBlocksCommonStyle() {
+export function useModelBlocksCommonStyle(): {
+  modelBlocksStyle: (id: string) => StyleValues;
+  modelBlockStyle: (id: string, block_id?: string) => StyleValues;
+  modelBlockColoring: (id: string, block_id?: string) => StyleValues;
+  mutateModelBlocksColoring: (
+    id: string,
+    blocks_ids: string[],
+    values: StyleValues,
+  ) => Promise<void>;
+  mutateModelBlocksTypeColoring: (id: string, values: StyleValues) => Promise<void>;
+} {
   const dataStyleState = useDataStyleState();
   const modelCommonStyle = useModelCommonStyle();
 
   function modelBlocksStyle(id: string): StyleValues {
-    return dataStyleState.getStyle(id).blocks as StyleValues;
+    return dataStyleState.getStyle(id).blocks ?? {};
   }
 
   function modelComponentTypeBlocksStyle(id: string): StyleValues {
@@ -27,17 +37,22 @@ export function useModelBlocksCommonStyle() {
   }
 
   function modelBlockColoring(id: string, block_id?: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring shape is defined by the data style schema.
     return modelBlockStyle(id, block_id).coloring as StyleValues;
   }
 
-  function mutateModelBlocksColoring(id: string, blocks_ids: string[], values: StyleValues) {
-    return modelCommonStyle.mutateComponentStyles(id, blocks_ids, {
+  async function mutateModelBlocksColoring(
+    id: string,
+    blocks_ids: string[],
+    values: StyleValues,
+  ): Promise<void> {
+    await modelCommonStyle.mutateComponentStyles(id, blocks_ids, {
       coloring: values,
     });
   }
 
-  function mutateModelBlocksTypeColoring(id: string, values: StyleValues) {
-    return modelCommonStyle.mutateModelComponentTypeStyle(id, "Block", {
+  async function mutateModelBlocksTypeColoring(id: string, values: StyleValues): Promise<void> {
+    await modelCommonStyle.mutateModelComponentTypeStyle(id, "Block", {
       coloring: values,
     });
   }

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

@@ -22,12 +22,21 @@ interface AttributeGroup {
   blocks_ids: string[];
 }
 
-async function setModelBlocksDefaultStyle(_id: string) {
+async function setModelBlocksDefaultStyle(_id: string): Promise<void> {
   // Placeholder
 }
 
+type UseModelBlocksStyleReturn = {
+  applyModelBlocksStyle: (modelId: string) => Promise<void>;
+  setModelBlocksDefaultStyle: (id: string) => Promise<void>;
+} & ReturnType<typeof useModelBlocksCommonStyle> &
+  ReturnType<typeof useModelBlocksVisibility> &
+  ReturnType<typeof useModelBlocksColor> &
+  ReturnType<typeof useModelBlocksVertexAttribute> &
+  ReturnType<typeof useModelBlocksPolyhedronAttribute>;
+
 // oxlint-disable-next-line max-lines-per-function
-export function useModelBlocksStyle() {
+export function useModelBlocksStyle(): UseModelBlocksStyleReturn {
   const dataStore = useDataStore();
   const modelCommonStyle = useModelBlocksCommonStyle();
   const modelVisibilityStyle = useModelBlocksVisibility();
@@ -35,30 +44,38 @@ export function useModelBlocksStyle() {
   const modelBlocksVertexAttribute = useModelBlocksVertexAttribute();
   const modelBlocksPolyhedronAttribute = useModelBlocksPolyhedronAttribute();
 
-  function applyModelBlocksVisibilityStyle(modelId: string, blocks_ids: string[]) {
+  async function applyModelBlocksVisibilityStyle(
+    modelId: string,
+    blocks_ids: string[],
+  ): Promise<unknown[]> {
     const visibilityGroups: Record<string, string[]> = {};
     for (const block_id of blocks_ids) {
       const style = modelCommonStyle.modelBlockStyle(modelId, block_id);
       const visibility = String(style.visibility);
-      if (!visibilityGroups[visibility]) {
-        visibilityGroups[visibility] = [];
-      }
+      visibilityGroups[visibility] ??= [];
       visibilityGroups[visibility].push(block_id);
     }
-    return Promise.all(
-      Object.entries(visibilityGroups).map(([visibility, ids]) =>
-        modelVisibilityStyle.setModelBlocksVisibility(modelId, ids, visibility === "true"),
-      ),
+    const result = await Promise.all(
+      Object.entries(visibilityGroups).map(async ([visibility, ids]) => {
+        const visibilityResult = await modelVisibilityStyle.setModelBlocksVisibility(
+          modelId,
+          ids,
+          visibility === "true",
+        );
+        return visibilityResult;
+      }),
     );
+    return result;
   }
 
-  function applyModelBlocksColoringStyle(modelId: string, blocks_ids: string[]) {
+  async function applyModelBlocksColoringStyle(
+    modelId: string,
+    blocks_ids: string[],
+  ): Promise<unknown[]> {
     const activeColoringGroups: Record<string, string[]> = {};
     for (const block_id of blocks_ids) {
       const activeColoring = String(modelColorStyle.modelBlockActiveColoring(modelId, block_id));
-      if (!activeColoringGroups[activeColoring]) {
-        activeColoringGroups[activeColoring] = [];
-      }
+      activeColoringGroups[activeColoring] ??= [];
       activeColoringGroups[activeColoring].push(block_id);
     }
 
@@ -70,15 +87,19 @@ export function useModelBlocksStyle() {
         for (const block_id of type_blocks_ids) {
           const color = modelColorStyle.modelBlockColor(modelId, block_id);
           const color_key = JSON.stringify(color);
-          if (!colorGroups[color_key]) {
-            colorGroups[color_key] = { color, blocks_ids: [] };
-          }
+          colorGroups[color_key] ??= { color, blocks_ids: [] };
           colorGroups[color_key].blocks_ids.push(block_id);
         }
         coloringPromises.push(
-          ...Object.values(colorGroups).map(({ color, blocks_ids: ids }) =>
-            modelColorStyle.setModelBlocksColor(modelId, ids, color, "constant"),
-          ),
+          ...Object.values(colorGroups).map(async ({ color, blocks_ids: ids }) => {
+            const result = await modelColorStyle.setModelBlocksColor(
+              modelId,
+              ids,
+              color,
+              "constant",
+            );
+            return result;
+          }),
         );
       } else if (type === "random") {
         coloringPromises.push(
@@ -102,28 +123,32 @@ export function useModelBlocksStyle() {
             continue;
           }
           const key = `${name}_${item}_${colorMap}_${minimum}_${maximum}`;
-          if (!vertexGroups[key]) {
-            vertexGroups[key] = {
-              name,
-              item,
-              minimum,
-              maximum,
-              colorMap,
-              blocks_ids: [],
-            };
-          }
+          vertexGroups[key] ??= {
+            name,
+            item,
+            minimum,
+            maximum,
+            colorMap,
+            blocks_ids: [],
+          };
           vertexGroups[key].blocks_ids.push(block_id);
         }
         coloringPromises.push(
           ...Object.values(vertexGroups).map(
-            ({ name, item, minimum, maximum, colorMap, blocks_ids: ids }) =>
-              modelBlocksVertexAttribute.setModelBlocksVertexAttribute(modelId, ids, {
-                name,
-                item,
-                minimum,
-                maximum,
-                colorMap,
-              }),
+            async ({ name, item, minimum, maximum, colorMap, blocks_ids: ids }) => {
+              const result = await modelBlocksVertexAttribute.setModelBlocksVertexAttribute(
+                modelId,
+                ids,
+                {
+                  name,
+                  item,
+                  minimum,
+                  maximum,
+                  colorMap,
+                },
+              );
+              return result;
+            },
           ),
         );
       } else if (type === "polyhedron") {
@@ -148,43 +173,48 @@ export function useModelBlocksStyle() {
             continue;
           }
           const key = `${name}_${item}_${colorMap}_${minimum}_${maximum}`;
-          if (!polyhedronGroups[key]) {
-            polyhedronGroups[key] = {
-              name,
-              item,
-              minimum,
-              maximum,
-              colorMap,
-              blocks_ids: [],
-            };
-          }
+          polyhedronGroups[key] ??= {
+            name,
+            item,
+            minimum,
+            maximum,
+            colorMap,
+            blocks_ids: [],
+          };
           polyhedronGroups[key].blocks_ids.push(block_id);
         }
         coloringPromises.push(
           ...Object.values(polyhedronGroups).map(
-            ({ name, item, minimum, maximum, colorMap, blocks_ids: ids }) =>
-              modelBlocksPolyhedronAttribute.setModelBlocksPolyhedronAttribute(modelId, ids, {
-                name,
-                item,
-                minimum,
-                maximum,
-                colorMap,
-              }),
+            async ({ name, item, minimum, maximum, colorMap, blocks_ids: ids }) => {
+              const result = await modelBlocksPolyhedronAttribute.setModelBlocksPolyhedronAttribute(
+                modelId,
+                ids,
+                {
+                  name,
+                  item,
+                  minimum,
+                  maximum,
+                  colorMap,
+                },
+              );
+              return result;
+            },
           ),
         );
       }
     }
 
-    return Promise.all(coloringPromises);
+    const result = await Promise.all(coloringPromises);
+    return result;
   }
 
-  async function applyModelBlocksStyle(modelId: string) {
+  async function applyModelBlocksStyle(modelId: string): Promise<void> {
     const blocks_ids = await dataStore.getBlocksGeodeIds(modelId);
     if (blocks_ids.length === 0) {
       return;
     }
 
-    return Promise.all([
+    await Promise.all([
       applyModelBlocksVisibilityStyle(modelId, blocks_ids),
       applyModelBlocksColoringStyle(modelId, blocks_ids),
     ]);