@geode/opengeodeweb-front 10.34.0-rc.2 → 10.34.0-rc.21

package/internal/stores/data_style/model/surfaces/{color.js → color.ts}

@@ -1,36 +1,72 @@
 import { isModelSurfacesPolygonAttributeValid, useModelSurfacesPolygonAttribute } from "./polygon";
 import { isModelSurfacesVertexAttributeValid, useModelSurfacesVertexAttribute } 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 { useModelSurfacesCommonStyle } from "./common";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 const schema = viewer_schemas.opengeodeweb_viewer.model.surfaces.color;
 
-export function useModelSurfacesColor() {
+export function useModelSurfacesColor(): {
+  setModelSurfacesColor: (
+    modelId: string,
+    surfaces_ids: string[],
+    color: unknown,
+    activeColoring?: string,
+  ) => Promise<unknown>;
+  modelSurfaceColoring: (id: string, surface_id?: string) => StyleValues;
+  modelSurfaceColor: (id: string, surface_id?: string) => unknown;
+  modelSurfaceActiveColoring: (id: string, surface_id?: string) => unknown;
+  setModelSurfacesActiveColoring: (
+    modelId: string,
+    surfaces_ids: string[],
+    activeColoring: string,
+  ) => Promise<unknown>;
+} {
+  const dataStore = useDataStore();
   const modelCommonStyle = useModelCommonStyle();
   const modelSurfacesCommonStyle = useModelSurfacesCommonStyle();
   const modelSurfacesVertexAttribute = useModelSurfacesVertexAttribute();
   const modelSurfacesPolygonAttribute = useModelSurfacesPolygonAttribute();
 
-  function modelSurfaceColoring(id, surface_id) {
-    return modelSurfacesCommonStyle.modelSurfaceStyle(id, surface_id).coloring;
+  function modelSurfaceColoring(id: string, surface_id?: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring shape is defined by the data style schema.
+    return modelSurfacesCommonStyle.modelSurfaceStyle(id, surface_id).coloring as StyleValues;
   }
 
-  function modelSurfaceColor(id, surface_id) {
+  function modelSurfaceColor(id: string, surface_id?: string): unknown {
     return modelSurfaceColoring(id, surface_id).constant;
   }
 
-  function setModelSurfacesColor(modelId, surfaces_ids, color, activeColoring = "constant") {
-    return modelCommonStyle.setModelTypeColor(modelId, surfaces_ids, color, schema, activeColoring);
+  async function setModelSurfacesColor(
+    modelId: string,
+    surfaces_ids: string[],
+    color: unknown,
+    activeColoring = "constant",
+  ): Promise<unknown> {
+    const result = await modelCommonStyle.setModelTypeColor(
+      modelId,
+      surfaces_ids,
+      color,
+      schema,
+      activeColoring,
+    );
+    return result;
   }
 
-  function modelSurfaceActiveColoring(id, surface_id) {
+  function modelSurfaceActiveColoring(id: string, surface_id?: string): unknown {
     return modelSurfaceColoring(id, surface_id).active;
   }
 
-  async function setModelSurfacesActiveColoring(modelId, surfaces_ids, activeColoring) {
-    if (surfaces_ids.length > 1) {
-      modelSurfacesCommonStyle.mutateModelSurfacesTypeColoring(modelId, {
+  async function setModelSurfacesActiveColoring(
+    modelId: string,
+    surfaces_ids: string[],
+    activeColoring: string,
+  ): Promise<unknown> {
+    const totalSurfaceIds = await dataStore.getSurfacesGeodeIds(modelId);
+    if (surfaces_ids.length === totalSurfaceIds.length) {
+      await modelSurfacesCommonStyle.mutateModelSurfacesTypeColoring(modelId, {
         active: activeColoring,
       });
     }
@@ -93,6 +129,7 @@ export function useModelSurfacesColor() {
         );
       }
     }
+    return undefined;
   }
 
   return {

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

@@ -0,0 +1,69 @@
+import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
+import merge from "lodash/merge";
+import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
+import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
+
+interface UseModelSurfacesCommonStyleReturn {
+  modelSurfacesStyle: (id: string) => StyleValues;
+  modelSurfaceStyle: (id: string, surface_id?: string) => StyleValues;
+  modelSurfaceColoring: (id: string, surface_id?: string) => StyleValues;
+  mutateModelSurfacesColoring: (
+    id: string,
+    surfaces_ids: readonly string[],
+    values: StyleValues,
+  ) => Promise<void>;
+  mutateModelSurfacesTypeColoring: (id: string, values: StyleValues) => Promise<void>;
+}
+
+export function useModelSurfacesCommonStyle(): UseModelSurfacesCommonStyleReturn {
+  const dataStyleState = useDataStyleState();
+  const modelCommonStyle = useModelCommonStyle();
+
+  function modelSurfacesStyle(id: string): StyleValues {
+    return dataStyleState.getStyle(id).surfaces ?? {};
+  }
+
+  function modelComponentTypeSurfacesStyle(id: string): StyleValues {
+    const defaultStyle = modelSurfacesStyle(id);
+    const typeStyle = dataStyleState.getModelComponentTypeStyle(id, "Surface");
+    return merge({}, defaultStyle, typeStyle);
+  }
+
+  function modelSurfaceStyle(id: string, surface_id?: string): StyleValues {
+    if (surface_id === undefined) {
+      return modelComponentTypeSurfacesStyle(id);
+    }
+    const typeStyle = modelComponentTypeSurfacesStyle(id);
+    const individualStyle = dataStyleState.getComponentStyle(id, surface_id);
+    return merge({}, typeStyle, individualStyle);
+  }
+
+  function modelSurfaceColoring(id: string, surface_id?: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring shape is defined by the data style schema.
+    return modelSurfaceStyle(id, surface_id).coloring as StyleValues;
+  }
+
+  async function mutateModelSurfacesColoring(
+    id: string,
+    surfaces_ids: readonly string[],
+    values: StyleValues,
+  ): Promise<void> {
+    await modelCommonStyle.mutateComponentStyles(id, [...surfaces_ids], {
+      coloring: values,
+    });
+  }
+
+  async function mutateModelSurfacesTypeColoring(id: string, values: StyleValues): Promise<void> {
+    await modelCommonStyle.mutateModelComponentTypeStyle(id, "Surface", {
+      coloring: values,
+    });
+  }
+
+  return {
+    modelSurfacesStyle,
+    modelSurfaceStyle,
+    modelSurfaceColoring,
+    mutateModelSurfacesColoring,
+    mutateModelSurfacesTypeColoring,
+  };
+}

package/internal/stores/data_style/model/surfaces/{index.js → index.ts}

@@ -5,10 +5,35 @@ import { useModelSurfacesColor } from "./color";
 import { useModelSurfacesCommonStyle } from "./common";
 import { useModelSurfacesVisibility } from "./visibility";
 
-async function setModelSurfacesDefaultStyle(_id) {
+interface ColorGroup {
+  color: unknown;
+  surfaces_ids: string[];
+}
+
+interface AttributeGroup {
+  name: string | undefined;
+  item: number | undefined;
+  minimum: number | undefined;
+  maximum: number | undefined;
+  colorMap: string | undefined;
+  surfaces_ids: string[];
+}
+
+async function setModelSurfacesDefaultStyle(_id: string): Promise<void> {
   // Placeholder
 }
-export function useModelSurfacesStyle() {
+
+type UseModelSurfacesStyleReturn = ReturnType<typeof useModelSurfacesCommonStyle> &
+  ReturnType<typeof useModelSurfacesVisibility> &
+  ReturnType<typeof useModelSurfacesColor> &
+  ReturnType<typeof useModelSurfacesVertexAttribute> &
+  ReturnType<typeof useModelSurfacesPolygonAttribute> & {
+    applyModelSurfacesStyle: (modelId: string) => Promise<void>;
+    setModelSurfacesDefaultStyle: (id: string) => Promise<void>;
+  };
+
+// oxlint-disable-next-line max-lines-per-function
+export function useModelSurfacesStyle(): UseModelSurfacesStyleReturn {
   const dataStore = useDataStore();
   const modelCommonStyle = useModelSurfacesCommonStyle();
   const modelVisibilityStyle = useModelSurfacesVisibility();
@@ -16,57 +41,70 @@ export function useModelSurfacesStyle() {
   const modelSurfacesVertexAttribute = useModelSurfacesVertexAttribute();
   const modelSurfacesPolygonAttribute = useModelSurfacesPolygonAttribute();
 
-  function applyModelSurfacesVisibilityStyle(modelId, surfaces_ids) {
-    const visibilityGroups = {};
+  async function applyModelSurfacesVisibilityStyle(
+    modelId: string,
+    surfaces_ids: string[],
+  ): Promise<void> {
+    const visibilityGroups: Record<string, string[]> = {};
     for (const surfaces_id of surfaces_ids) {
       const style = modelCommonStyle.modelSurfaceStyle(modelId, surfaces_id);
       const visibility = String(style.visibility);
-      if (!visibilityGroups[visibility]) {
-        visibilityGroups[visibility] = [];
-      }
+      visibilityGroups[visibility] ??= [];
       visibilityGroups[visibility].push(surfaces_id);
     }
-    return Promise.all(
-      Object.entries(visibilityGroups).map(([visibility, ids]) =>
-        modelVisibilityStyle.setModelSurfacesVisibility(modelId, ids, visibility === "true"),
-      ),
+    await Promise.all(
+      Object.entries(visibilityGroups).map(async ([visibility, ids]) => {
+        const result = await modelVisibilityStyle.setModelSurfacesVisibility(
+          modelId,
+          ids,
+          visibility === "true",
+        );
+        return result;
+      }),
     );
   }
 
-  function applyModelSurfacesColoringStyle(modelId, surfaces_ids) {
-    const activeColoringGroups = {};
+  async function applyModelSurfacesColoringStyle(
+    modelId: string,
+    surfaces_ids: string[],
+  ): Promise<unknown[]> {
+    const activeColoringGroups: Record<string, string[]> = {};
     for (const surfaces_id of surfaces_ids) {
-      const activeColoring = modelColorStyle.modelSurfaceActiveColoring(modelId, surfaces_id);
-      if (!activeColoringGroups[activeColoring]) {
-        activeColoringGroups[activeColoring] = [];
-      }
+      const activeColoring = String(
+        modelColorStyle.modelSurfaceActiveColoring(modelId, surfaces_id),
+      );
+      activeColoringGroups[activeColoring] ??= [];
       activeColoringGroups[activeColoring].push(surfaces_id);
     }
 
-    const coloringPromises = [];
+    const coloringPromises: Promise<unknown>[] = [];
 
     for (const [type, type_surfaces_ids] of Object.entries(activeColoringGroups)) {
       if (type === "constant") {
-        const colorGroups = {};
+        const colorGroups: Record<string, ColorGroup> = {};
         for (const surfaces_id of type_surfaces_ids) {
           const color = modelColorStyle.modelSurfaceColor(modelId, surfaces_id);
           const color_key = JSON.stringify(color);
-          if (!colorGroups[color_key]) {
-            colorGroups[color_key] = { color, surfaces_ids: [] };
-          }
+          colorGroups[color_key] ??= { color, surfaces_ids: [] };
           colorGroups[color_key].surfaces_ids.push(surfaces_id);
         }
         coloringPromises.push(
-          ...Object.values(colorGroups).map(({ color, surfaces_ids: ids }) =>
-            modelColorStyle.setModelSurfacesColor(modelId, ids, color, "constant"),
-          ),
+          ...Object.values(colorGroups).map(async ({ color, surfaces_ids: ids }) => {
+            const result = await modelColorStyle.setModelSurfacesColor(
+              modelId,
+              ids,
+              color,
+              "constant",
+            );
+            return result;
+          }),
         );
       } else if (type === "random") {
         coloringPromises.push(
           modelColorStyle.setModelSurfacesColor(modelId, type_surfaces_ids, undefined, "random"),
         );
       } else if (type === "vertex") {
-        const vertexGroups = {};
+        const vertexGroups: Record<string, AttributeGroup> = {};
         for (const surfaces_id of type_surfaces_ids) {
           const name = modelSurfacesVertexAttribute.modelSurfacesVertexAttributeName(
             modelId,
@@ -89,32 +127,36 @@ export function useModelSurfacesStyle() {
             continue;
           }
           const key = `${name}_${item}_${colorMap}_${minimum}_${maximum}`;
-          if (!vertexGroups[key]) {
-            vertexGroups[key] = {
-              name,
-              item,
-              minimum,
-              maximum,
-              colorMap,
-              surfaces_ids: [],
-            };
-          }
+          vertexGroups[key] ??= {
+            name,
+            item,
+            minimum,
+            maximum,
+            colorMap,
+            surfaces_ids: [],
+          };
           vertexGroups[key].surfaces_ids.push(surfaces_id);
         }
         coloringPromises.push(
           ...Object.values(vertexGroups).map(
-            ({ name, item, minimum, maximum, colorMap, surfaces_ids: ids }) =>
-              modelSurfacesVertexAttribute.setModelSurfacesVertexAttribute(modelId, ids, {
-                name,
-                item,
-                minimum,
-                maximum,
-                colorMap,
-              }),
+            async ({ name, item, minimum, maximum, colorMap, surfaces_ids: ids }) => {
+              const result = await modelSurfacesVertexAttribute.setModelSurfacesVertexAttribute(
+                modelId,
+                ids,
+                {
+                  name,
+                  item,
+                  minimum,
+                  maximum,
+                  colorMap,
+                },
+              );
+              return result;
+            },
           ),
         );
       } else if (type === "polygon") {
-        const polygonGroups = {};
+        const polygonGroups: Record<string, AttributeGroup> = {};
         for (const surfaces_id of type_surfaces_ids) {
           const name = modelSurfacesPolygonAttribute.modelSurfacesPolygonAttributeName(
             modelId,
@@ -135,41 +177,46 @@ export function useModelSurfacesStyle() {
             continue;
           }
           const key = `${name}_${item}_${colorMap}_${minimum}_${maximum}`;
-          if (!polygonGroups[key]) {
-            polygonGroups[key] = {
-              name,
-              item,
-              minimum,
-              maximum,
-              colorMap,
-              surfaces_ids: [],
-            };
-          }
+          polygonGroups[key] ??= {
+            name,
+            item,
+            minimum,
+            maximum,
+            colorMap,
+            surfaces_ids: [],
+          };
           polygonGroups[key].surfaces_ids.push(surfaces_id);
         }
         coloringPromises.push(
           ...Object.values(polygonGroups).map(
-            ({ name, item, minimum, maximum, colorMap, surfaces_ids: ids }) =>
-              modelSurfacesPolygonAttribute.setModelSurfacesPolygonAttribute(modelId, ids, {
-                name,
-                item,
-                minimum,
-                maximum,
-                colorMap,
-              }),
+            async ({ name, item, minimum, maximum, colorMap, surfaces_ids: ids }) => {
+              const result = await modelSurfacesPolygonAttribute.setModelSurfacesPolygonAttribute(
+                modelId,
+                ids,
+                {
+                  name,
+                  item,
+                  minimum,
+                  maximum,
+                  colorMap,
+                },
+              );
+              return result;
+            },
           ),
         );
       }
     }
-    return Promise.all(coloringPromises);
+    const results = await Promise.all(coloringPromises);
+    return results;
   }
 
-  async function applyModelSurfacesStyle(modelId) {
+  async function applyModelSurfacesStyle(modelId: string): Promise<void> {
     const surfaces_ids = await dataStore.getSurfacesGeodeIds(modelId);
     if (surfaces_ids.length === 0) {
       return;
     }
-    return Promise.all([
+    await Promise.all([
       applyModelSurfacesVisibilityStyle(modelId, surfaces_ids),
       applyModelSurfacesColoringStyle(modelId, surfaces_ids),
     ]);