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

package/internal/stores/data_style/model/selection.ts

@@ -1,14 +1,7 @@
-// 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 {
-  ModelComponentStyle,
-  ModelComponentTypeStyle,
-  StyleValues,
-} from "@ogw_internal/stores/data_style/types.js";
 import { MESH_COMPONENT_TYPES } from "@ogw_front/utils/default_styles";
-import { database } from "@ogw_internal/database/database";
+import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
 import type { Table } from "dexie";
-import type { ComputedRef, Ref } from "vue";
+import { database } from "@ogw_internal/database/database";
 import type { useDataStyleState } from "@ogw_internal/stores/data_style/state";
 
 interface ModelComponentRecord {
@@ -19,80 +12,115 @@ interface ModelComponentRecord {
 
 type DataStyleState = ReturnType<typeof useDataStyleState>;
 
+// oxlint-disable-next-line no-unsafe-type-assertion -- trusted Dexie table boundary; see other database table casts in this codebase.
 const model_components_db = database.model_components as unknown as Table<
   ModelComponentRecord,
   string
 >;
 
-function buildSelection(
-  modelId: string,
-  components: ModelComponentRecord[],
-  componentStyles: Ref<Record<string, ModelComponentStyle>>,
-  modelComponentTypeStyles: Ref<Record<string, ModelComponentTypeStyle>>,
-  dataStyleState: DataStyleState,
-): string[] {
+function groupComponentsByType(
+  components: readonly ModelComponentRecord[],
+): Record<string, ModelComponentRecord[]> {
   const componentsByType: Record<string, ModelComponentRecord[]> = Object.fromEntries(
     MESH_COMPONENT_TYPES.map((componentType) => [componentType, []]),
   );
   for (const component of components) {
-    if (componentsByType[component.type]) {
-      componentsByType[component.type]!.push(component);
+    const list = componentsByType[component.type];
+    if (list !== undefined) {
+      list.push(component);
     }
   }
+  return componentsByType;
+}
 
+interface TypeSelectionContext {
+  readonly modelId: string;
+  readonly groupStyles: ReturnType<DataStyleState["getStyle"]>;
+  readonly dataStyleState: DataStyleState;
+}
+
+function computeTypeSelection(
+  componentType: string,
+  typeComponents: readonly ModelComponentRecord[],
+  context: TypeSelectionContext,
+): string[] {
+  const { modelId, groupStyles, dataStyleState } = context;
+  const typeKey = `${componentType.toLowerCase()}s`;
+  const typeStyleKey = `${modelId}_${componentType}`;
+  const typeStyle = dataStyleState.modelComponentTypeStyles.value[typeStyleKey];
+  // oxlint-disable-next-line no-unsafe-type-assertion -- dynamically-keyed lookup into StyleValues; see other database/style casts in this codebase.
+  const groupTypeStyle = (groupStyles as unknown as Record<string, StyleValues | undefined>)[
+    typeKey
+  ];
+  const defaultVisibility =
+    // oxlint-disable-next-line no-unsafe-type-assertion -- visibility field is defined by the data style schema.
+    (typeStyle?.visibility as boolean | undefined) ??
+    // oxlint-disable-next-line no-unsafe-type-assertion -- visibility field is defined by the data style schema.
+    (groupTypeStyle?.visibility as boolean | undefined) ??
+    true;
+
+  const selection: string[] = [];
+  let allVisible = true;
+  for (const component of typeComponents) {
+    const styleKey = `${modelId}_${component.geode_id}`;
+    const componentStyle = dataStyleState.componentStyles.value[styleKey];
+    // oxlint-disable-next-line no-unsafe-type-assertion -- visibility field is defined by the data style schema.
+    const isVisible = (componentStyle?.visibility as boolean | undefined) ?? defaultVisibility;
+    if (isVisible) {
+      selection.push(component.geode_id);
+    } else {
+      allVisible = false;
+    }
+  }
+  if (allVisible) {
+    selection.push(componentType);
+  }
+  return selection;
+}
+
+function buildSelection(
+  modelId: string,
+  components: readonly ModelComponentRecord[],
+  dataStyleState: DataStyleState,
+): string[] {
+  const componentsByType = groupComponentsByType(components);
   const groupStyles = dataStyleState.getStyle(modelId);
+  const context: TypeSelectionContext = { modelId, groupStyles, dataStyleState };
+
   const selection: string[] = [];
   for (const componentType of MESH_COMPONENT_TYPES) {
-    const typeComponents = componentsByType[componentType];
-    if (!typeComponents || typeComponents.length === 0) {
+    const typeComponents = componentsByType[componentType] ?? [];
+    if (typeComponents.length === 0) {
       continue;
     }
-
-    const typeKey = `${componentType.toLowerCase()}s`;
-    const typeStyleKey = `${modelId}_${componentType}`;
-    const typeStyle = modelComponentTypeStyles.value[typeStyleKey];
-    const defaultVisibility =
-      (typeStyle?.visibility as boolean | undefined) ??
-      ((groupStyles[typeKey] as StyleValues | undefined)?.visibility as boolean | undefined) ??
-      true;
-
-    let allVisible = true;
-    for (const component of typeComponents) {
-      const styleKey = `${modelId}_${component.geode_id}`;
-      const isVisible =
-        (componentStyles.value[styleKey]?.visibility as boolean | undefined) ?? defaultVisibility;
-      if (isVisible) {
-        selection.push(component.geode_id);
-      } else {
-        allVisible = false;
-      }
-    }
-    if (allVisible) {
-      selection.push(componentType);
-    }
+    selection.push(...computeTypeSelection(componentType, typeComponents, context));
   }
   return selection;
 }
 
 const selectionCache = new Map<string, ComputedRef<string[]>>();
 
-function useModelSelection(modelId: string | undefined, dataStyleState: DataStyleState) {
-  if (!modelId) {
+function useModelSelection(
+  modelId: string | undefined,
+  dataStyleState: DataStyleState,
+): ComputedRef<string[]> {
+  if (modelId === undefined || modelId === "") {
     return computed<string[]>(() => []);
   }
 
-  const cacheKey = `${modelId}`;
-  if (selectionCache.has(cacheKey)) {
-    return selectionCache.get(cacheKey)!;
+  const cacheKey = modelId;
+  const cachedSelection = selectionCache.get(cacheKey);
+  if (cachedSelection !== undefined) {
+    return cachedSelection;
   }
 
   const allComponents = ref<ModelComponentRecord[]>([]);
 
-  (async () => {
+  void (async (): Promise<void> => {
     try {
       allComponents.value = await model_components_db.where("id").equals(modelId).toArray();
-    } catch (error) {
-      console.error("Error fetching model components:", error);
+    } catch {
+      allComponents.value = [];
     }
   })();
 
@@ -100,13 +128,7 @@ function useModelSelection(modelId: string | undefined, dataStyleState: DataStyl
     if (allComponents.value.length === 0) {
       return [];
     }
-    return buildSelection(
-      modelId,
-      allComponents.value,
-      dataStyleState.componentStyles,
-      dataStyleState.modelComponentTypeStyles,
-      dataStyleState,
-    );
+    return buildSelection(modelId, allComponents.value, dataStyleState);
   });
 
   selectionCache.set(cacheKey, computedSelection);

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

@@ -1,21 +1,39 @@
-// 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 { 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,
+    collectionId?: 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,
+    collectionId?: string,
+  ) => Promise<unknown>;
+} {
+  const dataStore = useDataStore();
   const modelCommonStyle = useModelCommonStyle();
   const modelSurfacesCommonStyle = useModelSurfacesCommonStyle();
   const modelSurfacesVertexAttribute = useModelSurfacesVertexAttribute();
   const modelSurfacesPolygonAttribute = useModelSurfacesPolygonAttribute();
 
   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;
   }
 
@@ -23,13 +41,22 @@ export function useModelSurfacesColor() {
     return modelSurfaceColoring(id, surface_id).constant;
   }
 
-  function setModelSurfacesColor(
+  async function setModelSurfacesColor(
     modelId: string,
     surfaces_ids: string[],
     color: unknown,
     activeColoring = "constant",
-  ) {
-    return modelCommonStyle.setModelTypeColor(modelId, surfaces_ids, color, schema, activeColoring);
+    collectionId?: string,
+  ): Promise<unknown> {
+    const result = await modelCommonStyle.setModelTypeColor(
+      modelId,
+      surfaces_ids,
+      color,
+      schema,
+      activeColoring,
+      collectionId,
+    );
+    return result;
   }
 
   function modelSurfaceActiveColoring(id: string, surface_id?: string): unknown {
@@ -40,9 +67,11 @@ export function useModelSurfacesColor() {
     modelId: string,
     surfaces_ids: string[],
     activeColoring: string,
-  ) {
-    if (surfaces_ids.length > 1) {
-      modelSurfacesCommonStyle.mutateModelSurfacesTypeColoring(modelId, {
+    collectionId?: string,
+  ): Promise<unknown> {
+    const totalSurfaceIds = await dataStore.getSurfacesGeodeIds(modelId);
+    if (surfaces_ids.length === totalSurfaceIds.length) {
+      await modelSurfacesCommonStyle.mutateModelSurfacesTypeColoring(modelId, {
         active: activeColoring,
       });
     }
@@ -51,7 +80,7 @@ export function useModelSurfacesColor() {
     });
     if (activeColoring === "constant" || activeColoring === "random") {
       const color = modelSurfaceColor(modelId, surfaces_ids[0]);
-      return setModelSurfacesColor(modelId, surfaces_ids, color, activeColoring);
+      return setModelSurfacesColor(modelId, surfaces_ids, color, activeColoring, collectionId);
     }
 
     if (activeColoring === "vertex") {
@@ -105,6 +134,7 @@ export function useModelSurfacesColor() {
         );
       }
     }
+    return undefined;
   }
 
   return {

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

@@ -3,12 +3,24 @@ 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 useModelSurfacesCommonStyle() {
+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 as StyleValues;
+    return dataStyleState.getStyle(id).surfaces ?? {};
   }
 
   function modelComponentTypeSurfacesStyle(id: string): StyleValues {
@@ -27,17 +39,22 @@ export function useModelSurfacesCommonStyle() {
   }
 
   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;
   }
 
-  function mutateModelSurfacesColoring(id: string, surfaces_ids: string[], values: StyleValues) {
-    return modelCommonStyle.mutateComponentStyles(id, surfaces_ids, {
+  async function mutateModelSurfacesColoring(
+    id: string,
+    surfaces_ids: readonly string[],
+    values: StyleValues,
+  ): Promise<void> {
+    await modelCommonStyle.mutateComponentStyles(id, [...surfaces_ids], {
       coloring: values,
     });
   }
 
-  function mutateModelSurfacesTypeColoring(id: string, values: StyleValues) {
-    return modelCommonStyle.mutateModelComponentTypeStyle(id, "Surface", {
+  async function mutateModelSurfacesTypeColoring(id: string, values: StyleValues): Promise<void> {
+    await modelCommonStyle.mutateModelComponentTypeStyle(id, "Surface", {
       coloring: values,
     });
   }

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

@@ -19,11 +19,21 @@ interface AttributeGroup {
   surfaces_ids: string[];
 }
 
-async function setModelSurfacesDefaultStyle(_id: string) {
+async function setModelSurfacesDefaultStyle(_id: string): Promise<void> {
   // Placeholder
 }
+
+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() {
+export function useModelSurfacesStyle(): UseModelSurfacesStyleReturn {
   const dataStore = useDataStore();
   const modelCommonStyle = useModelSurfacesCommonStyle();
   const modelVisibilityStyle = useModelSurfacesVisibility();
@@ -31,32 +41,39 @@ export function useModelSurfacesStyle() {
   const modelSurfacesVertexAttribute = useModelSurfacesVertexAttribute();
   const modelSurfacesPolygonAttribute = useModelSurfacesPolygonAttribute();
 
-  function applyModelSurfacesVisibilityStyle(modelId: string, surfaces_ids: string[]) {
+  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: string, surfaces_ids: string[]) {
+  async function applyModelSurfacesColoringStyle(
+    modelId: string,
+    surfaces_ids: string[],
+  ): Promise<unknown[]> {
     const activeColoringGroups: Record<string, string[]> = {};
     for (const surfaces_id of surfaces_ids) {
       const activeColoring = String(
         modelColorStyle.modelSurfaceActiveColoring(modelId, surfaces_id),
       );
-      if (!activeColoringGroups[activeColoring]) {
-        activeColoringGroups[activeColoring] = [];
-      }
+      activeColoringGroups[activeColoring] ??= [];
       activeColoringGroups[activeColoring].push(surfaces_id);
     }
 
@@ -68,15 +85,19 @@ export function useModelSurfacesStyle() {
         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(
@@ -106,28 +127,32 @@ 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") {
@@ -152,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: string) {
+  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),
     ]);