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

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

@@ -0,0 +1,343 @@
+// 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";
+
+// Local imports
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
+import { useDataStore } from "@ogw_front/stores/data";
+import { useModelLinesCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
+
+// Local constants
+const attributeSchema = viewer_schemas.opengeodeweb_viewer.model.lines.attribute.edge.attribute;
+
+interface AttributeStoredConfig {
+  minimum: number | undefined;
+  maximum: number | undefined;
+  colorMap: string | undefined;
+  no_data_color: unknown;
+}
+
+interface AttributeState {
+  name?: string;
+  item?: number;
+  storedConfigs?: Record<string, { lastItem: number } & Record<string, AttributeStoredConfig>>;
+}
+
+interface AttributeInput {
+  name: string | undefined;
+  item: number | undefined;
+  minimum: number | undefined;
+  maximum: number | undefined;
+  colorMap: string | undefined;
+  no_data_color?: unknown;
+}
+
+function isModelLinesEdgeAttributeValid({
+  name,
+  item,
+  minimum,
+  maximum,
+  colorMap,
+}: AttributeInput): boolean {
+  return (
+    name !== undefined &&
+    item !== undefined &&
+    minimum !== undefined &&
+    maximum !== undefined &&
+    colorMap !== undefined
+  );
+}
+
+interface UseModelLinesEdgeAttributeReturn {
+  modelLinesEdgeAttributeName: (modelId: string, lineId?: string) => string | undefined;
+  modelLinesEdgeAttributeItem: (modelId: string, lineId?: string) => number;
+  modelLinesEdgeAttributeRange: (
+    modelId: string,
+    lineId?: string,
+  ) => [number | undefined, number | undefined];
+  modelLinesEdgeAttributeColorMap: (modelId: string, lineId?: string) => string | undefined;
+  modelLinesEdgeAttributeStoredConfig: (
+    modelId: string,
+    lineId: string | undefined,
+    name: string | undefined,
+    item: number | undefined,
+  ) => AttributeStoredConfig;
+  setModelLinesEdgeAttribute: (
+    modelId: string,
+    lineIds: string[],
+    input: AttributeInput,
+  ) => Promise<unknown>;
+  setModelLinesEdgeAttributeName: (
+    modelId: string,
+    lineIds: string[],
+    name: string,
+  ) => Promise<unknown>;
+  setModelLinesEdgeAttributeItem: (
+    modelId: string,
+    lineIds: string[],
+    item: number,
+  ) => Promise<unknown>;
+  setModelLinesEdgeAttributeRange: (
+    modelId: string,
+    lineIds: string[],
+    minimum: number,
+    maximum: number,
+  ) => Promise<unknown>;
+  setModelLinesEdgeAttributeColorMap: (
+    modelId: string,
+    lineIds: string[],
+    colorMap: string | undefined,
+  ) => Promise<unknown>;
+  modelLinesEdgeAttributeNoDataColor: (modelId: string, lineId?: string) => unknown;
+  setModelLinesEdgeAttributeNoDataColor: (
+    modelId: string,
+    lineIds: string[],
+    no_data_color: unknown,
+  ) => Promise<unknown>;
+}
+
+// oxlint-disable-next-line max-lines-per-function
+function useModelLinesEdgeAttribute(): UseModelLinesEdgeAttributeReturn {
+  const dataStore = useDataStore();
+  const modelLinesCommonStyle = useModelLinesCommonStyle();
+  const viewerStore = useViewerStore();
+  function modelLinesEdgeAttribute(modelId: string, lineId?: string): AttributeState {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring.edge shape is defined by the data style schema.
+    return modelLinesCommonStyle.modelLineColoring(modelId, lineId).edge as AttributeState;
+  }
+  function modelLinesEdgeAttributeStoredConfig(
+    modelId: string,
+    lineId: string | undefined,
+    name: string | undefined,
+    item: number | undefined,
+  ): AttributeStoredConfig {
+    const { storedConfigs } = modelLinesEdgeAttribute(modelId, lineId);
+    const nameConfig = name === undefined ? undefined : storedConfigs?.[name];
+    const itemConfig = item === undefined ? undefined : nameConfig?.[item];
+    if (itemConfig !== undefined) {
+      return itemConfig;
+    }
+    return {
+      minimum: undefined,
+      maximum: undefined,
+      colorMap: undefined,
+      no_data_color: DEFAULT_NO_DATA_COLOR,
+    };
+  }
+  async function mutateModelLinesEdgeStyle(
+    modelId: string,
+    lineIds: string[],
+    values: Record<string, unknown>,
+  ): Promise<void> {
+    const tasks: Promise<void>[] = [
+      modelLinesCommonStyle.mutateModelLinesColoring(modelId, lineIds, {
+        edge: values,
+      }),
+    ];
+    const totalLineIds = await dataStore.getLinesGeodeIds(modelId);
+    if (lineIds.length === totalLineIds.length) {
+      tasks.push(
+        modelLinesCommonStyle.mutateModelLinesTypeColoring(modelId, {
+          edge: values,
+        }),
+      );
+    }
+    await Promise.all(tasks);
+  }
+  async function setModelLinesEdgeAttributeStoredConfig(
+    modelId: string,
+    lineIds: string[],
+    name: string | undefined,
+    item: number | undefined,
+    config: Partial<AttributeStoredConfig>,
+  ): Promise<void> {
+    if (name === undefined || item === undefined) {
+      return;
+    }
+    await mutateModelLinesEdgeStyle(modelId, lineIds, {
+      storedConfigs: {
+        [name]: {
+          lastItem: item,
+          [item]: config,
+        },
+      },
+    });
+  }
+  function modelLinesEdgeAttributeName(modelId: string, lineId?: string): string | undefined {
+    return modelLinesEdgeAttribute(modelId, lineId).name;
+  }
+  function modelLinesEdgeAttributeLastItem(
+    modelId: string,
+    lineId: string | undefined,
+    name: string | undefined,
+  ): number {
+    const { storedConfigs } = modelLinesEdgeAttribute(modelId, lineId);
+    const nameConfig = name === undefined ? undefined : storedConfigs?.[name];
+    if (nameConfig !== undefined) {
+      return nameConfig.lastItem;
+    }
+    return 0;
+  }
+  function modelLinesEdgeAttributeItem(modelId: string, lineId?: string): number {
+    const edgeAttribute = modelLinesEdgeAttribute(modelId, lineId);
+    return (
+      edgeAttribute.item ?? modelLinesEdgeAttributeLastItem(modelId, lineId, edgeAttribute.name)
+    );
+  }
+  function modelLinesEdgeAttributeRange(
+    modelId: string,
+    lineId?: string,
+  ): [number | undefined, number | undefined] {
+    const name = modelLinesEdgeAttributeName(modelId, lineId);
+    const item = modelLinesEdgeAttributeItem(modelId, lineId);
+    const storedConfig = modelLinesEdgeAttributeStoredConfig(modelId, lineId, name, item);
+    const { minimum, maximum } = storedConfig;
+    return [minimum, maximum];
+  }
+  function modelLinesEdgeAttributeColorMap(modelId: string, lineId?: string): string | undefined {
+    const name = modelLinesEdgeAttributeName(modelId, lineId);
+    const item = modelLinesEdgeAttributeItem(modelId, lineId);
+    const storedConfig = modelLinesEdgeAttributeStoredConfig(modelId, lineId, name, item);
+    return storedConfig.colorMap;
+  }
+  async function setModelLinesEdgeAttribute(
+    modelId: string,
+    lineIds: string[],
+    {
+      name,
+      item,
+      minimum,
+      maximum,
+      colorMap,
+      no_data_color = DEFAULT_NO_DATA_COLOR,
+    }: AttributeInput,
+  ): Promise<unknown> {
+    await mutateModelLinesEdgeStyle(modelId, lineIds, {
+      name,
+      item,
+    });
+    await setModelLinesEdgeAttributeStoredConfig(modelId, lineIds, name, item, {
+      minimum,
+      maximum,
+      colorMap,
+      no_data_color,
+    });
+    const points = getRGBPointsFromPreset(colorMap ?? "");
+    const line_viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, lineIds);
+    const params = {
+      id: modelId,
+      block_ids: line_viewer_ids,
+      name,
+      item,
+      points,
+      minimum,
+      maximum,
+      no_data_color,
+    };
+    return viewerStore.request({
+      schema: attributeSchema,
+      params,
+    });
+  }
+  async function applyEdgeAttribute(modelId: string, lineIds: string[]): Promise<void> {
+    const name = modelLinesEdgeAttributeName(modelId, lineIds[0]);
+    const item = modelLinesEdgeAttributeItem(modelId, lineIds[0]);
+    const storedConfig = modelLinesEdgeAttributeStoredConfig(modelId, lineIds[0], name, item);
+    const attribute: AttributeInput = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+      no_data_color: storedConfig.no_data_color,
+    };
+    if (isModelLinesEdgeAttributeValid(attribute)) {
+      await setModelLinesEdgeAttribute(modelId, lineIds, attribute);
+    }
+  }
+  async function setModelLinesEdgeAttributeName(
+    modelId: string,
+    lineIds: string[],
+    name: string,
+  ): Promise<unknown> {
+    const item = modelLinesEdgeAttributeLastItem(modelId, lineIds[0], name);
+    await mutateModelLinesEdgeStyle(modelId, lineIds, {
+      name,
+      item,
+    });
+    return applyEdgeAttribute(modelId, lineIds);
+  }
+  async function setModelLinesEdgeAttributeItem(
+    modelId: string,
+    lineIds: string[],
+    item: number,
+  ): Promise<unknown> {
+    await mutateModelLinesEdgeStyle(modelId, lineIds, {
+      item,
+    });
+    return applyEdgeAttribute(modelId, lineIds);
+  }
+  async function setModelLinesEdgeAttributeRange(
+    modelId: string,
+    lineIds: string[],
+    minimum: number,
+    maximum: number,
+  ): Promise<unknown> {
+    const name = modelLinesEdgeAttributeName(modelId, lineIds[0]);
+    const item = modelLinesEdgeAttributeItem(modelId, lineIds[0]);
+    await setModelLinesEdgeAttributeStoredConfig(modelId, lineIds, name, item, {
+      minimum,
+      maximum,
+    });
+    return applyEdgeAttribute(modelId, lineIds);
+  }
+  async function setModelLinesEdgeAttributeColorMap(
+    modelId: string,
+    lineIds: string[],
+    colorMap: string | undefined,
+  ): Promise<unknown> {
+    const name = modelLinesEdgeAttributeName(modelId, lineIds[0]);
+    const item = modelLinesEdgeAttributeItem(modelId, lineIds[0]);
+    await setModelLinesEdgeAttributeStoredConfig(modelId, lineIds, name, item, {
+      colorMap,
+    });
+    return applyEdgeAttribute(modelId, lineIds);
+  }
+  function modelLinesEdgeAttributeNoDataColor(modelId: string, lineId?: string): unknown {
+    const name = modelLinesEdgeAttributeName(modelId, lineId);
+    const item = modelLinesEdgeAttributeItem(modelId, lineId);
+    const storedConfig = modelLinesEdgeAttributeStoredConfig(modelId, lineId, name, item);
+    return storedConfig.no_data_color;
+  }
+  async function setModelLinesEdgeAttributeNoDataColor(
+    modelId: string,
+    lineIds: string[],
+    no_data_color: unknown,
+  ): Promise<unknown> {
+    const name = modelLinesEdgeAttributeName(modelId, lineIds[0]);
+    const item = modelLinesEdgeAttributeItem(modelId, lineIds[0]);
+    const storedConfig = modelLinesEdgeAttributeStoredConfig(modelId, lineIds[0], name, item);
+    await setModelLinesEdgeAttributeStoredConfig(modelId, lineIds, name, item, {
+      ...storedConfig,
+      no_data_color,
+    });
+    return applyEdgeAttribute(modelId, lineIds);
+  }
+  return {
+    modelLinesEdgeAttributeName,
+    modelLinesEdgeAttributeItem,
+    modelLinesEdgeAttributeRange,
+    modelLinesEdgeAttributeColorMap,
+    modelLinesEdgeAttributeStoredConfig,
+    setModelLinesEdgeAttribute,
+    setModelLinesEdgeAttributeName,
+    setModelLinesEdgeAttributeItem,
+    setModelLinesEdgeAttributeRange,
+    setModelLinesEdgeAttributeColorMap,
+    modelLinesEdgeAttributeNoDataColor,
+    setModelLinesEdgeAttributeNoDataColor,
+  };
+}
+export { isModelLinesEdgeAttributeValid, useModelLinesEdgeAttribute };

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

@@ -5,11 +5,33 @@ import { useModelLinesColor } from "./color";
 import { useModelLinesCommonStyle } from "./common";
 import { useModelLinesVisibility } from "./visibility";
 
-async function setModelLinesDefaultStyle(_id) {
+interface ColorGroup {
+  color: unknown;
+  lines_ids: string[];
+}
+
+interface AttributeGroup {
+  name: string | undefined;
+  item: number | undefined;
+  minimum: number | undefined;
+  maximum: number | undefined;
+  colorMap: string | undefined;
+  lines_ids: string[];
+}
+
+async function setModelLinesDefaultStyle(_id: string): Promise<void> {
   // Placeholder
 }
 
-export function useModelLinesStyle() {
+// oxlint-disable-next-line max-lines-per-function
+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();
@@ -17,57 +39,68 @@ export function useModelLinesStyle() {
   const modelLinesVertexAttribute = useModelLinesVertexAttribute();
   const modelLinesEdgeAttribute = useModelLinesEdgeAttribute();
 
-  function applyModelLinesVisibilityStyle(modelId, lines_ids) {
-    const visibilityGroups = {};
+  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, lines_ids) {
-    const activeColoringGroups = {};
+  async function applyModelLinesColoringStyle(
+    modelId: string,
+    lines_ids: string[],
+  ): Promise<unknown[]> {
+    const activeColoringGroups: Record<string, string[]> = {};
     for (const line_id of lines_ids) {
-      const activeColoring = modelColorStyle.modelLineActiveColoring(modelId, line_id);
-      if (!activeColoringGroups[activeColoring]) {
-        activeColoringGroups[activeColoring] = [];
-      }
+      const activeColoring = String(modelColorStyle.modelLineActiveColoring(modelId, line_id));
+      activeColoringGroups[activeColoring] ??= [];
       activeColoringGroups[activeColoring].push(line_id);
     }
 
-    const coloringPromises = [];
+    const coloringPromises: Promise<unknown>[] = [];
 
     for (const [type, type_lines_ids] of Object.entries(activeColoringGroups)) {
       if (type === "constant") {
-        const colorGroups = {};
+        const colorGroups: Record<string, ColorGroup> = {};
         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(
           modelColorStyle.setModelLinesColor(modelId, type_lines_ids, undefined, "random"),
         );
       } else if (type === "vertex") {
-        const vertexGroups = {};
+        const vertexGroups: Record<string, AttributeGroup> = {};
         for (const line_id of type_lines_ids) {
           const name = modelLinesVertexAttribute.modelLinesVertexAttributeName(modelId, line_id);
           const item = modelLinesVertexAttribute.modelLinesVertexAttributeItem(modelId, line_id);
@@ -84,32 +117,36 @@ 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") {
-        const edgeGroups = {};
+        const edgeGroups: Record<string, AttributeGroup> = {};
         for (const line_id of type_lines_ids) {
           const name = modelLinesEdgeAttribute.modelLinesEdgeAttributeName(modelId, line_id);
           const item = modelLinesEdgeAttribute.modelLinesEdgeAttributeItem(modelId, line_id);
@@ -126,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) {
+  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),
     ]);