@geode/opengeodeweb-front 10.38.0 → 10.39.0

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

@@ -4,6 +4,10 @@ import { DEFAULT_NO_DATA_COLOR, type RGBAColor } from "@ogw_front/utils/default_
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 
 // Local imports
+import {
+  reapplySameSeries,
+  useAttributeTimeStepStyle,
+} from "@ogw_internal/stores/data_style/time_step";
 import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useModelBlocksCommonStyle } from "./common";
@@ -60,6 +64,12 @@ interface UseModelBlocksVertexAttributeReturn {
     modelId: string,
     blockId?: string,
   ) => [number | undefined, number | undefined];
+  modelBlocksVertexAttributeTimeStep: (modelId: string, blockId?: string) => number | undefined;
+  setModelBlocksVertexAttributeTimeStep: (
+    modelId: string,
+    blockIds: string[],
+    timeStep: number,
+  ) => Promise<void>;
   modelBlocksVertexAttributeColorMap: (modelId: string, blockId?: string) => string | undefined;
   modelBlocksVertexAttributeStoredConfig: (
     modelId: string,
@@ -103,6 +113,7 @@ interface UseModelBlocksVertexAttributeReturn {
 
 // oxlint-disable-next-line max-lines-per-function
 function useModelBlocksVertexAttribute(): UseModelBlocksVertexAttributeReturn {
+  const { attributeTimeStep, setAttributeTimeStep, seriesArrayName } = useAttributeTimeStepStyle();
   const dataStore = useDataStore();
   const modelBlocksCommonStyle = useModelBlocksCommonStyle();
   const viewerStore = useViewerStore();
@@ -209,6 +220,22 @@ function useModelBlocksVertexAttribute(): UseModelBlocksVertexAttributeReturn {
     const storedConfig = modelBlocksVertexAttributeStoredConfig(modelId, blockId, name, item);
     return storedConfig.colorMap;
   }
+  function modelBlocksVertexAttributeNoDataColor(modelId: string, blockId?: string): RGBAColor {
+    const name = modelBlocksVertexAttributeName(modelId, blockId);
+    const item = modelBlocksVertexAttributeItem(modelId, blockId);
+    const storedConfig = modelBlocksVertexAttributeStoredConfig(modelId, blockId, name, item);
+    return storedConfig.no_data_color;
+  }
+  function modelBlocksVertexAttributeTimeStep(
+    modelId: string,
+    blockId?: string,
+  ): number | undefined {
+    return attributeTimeStep(
+      modelId,
+      attributeSchema.$id,
+      modelBlocksVertexAttribute(modelId, blockId).name,
+    );
+  }
   async function setModelBlocksVertexAttribute(
     modelId: string,
     blockIds: string[],
@@ -236,7 +263,7 @@ function useModelBlocksVertexAttribute(): UseModelBlocksVertexAttributeReturn {
     const params = {
       id: modelId,
       block_ids: block_viewer_ids,
-      name,
+      name: seriesArrayName(modelId, attributeSchema.$id, name),
       item,
       points,
       minimum,
@@ -288,6 +315,37 @@ function useModelBlocksVertexAttribute(): UseModelBlocksVertexAttributeReturn {
     });
     return applyVertexAttribute(modelId, blockIds);
   }
+  async function setModelBlocksVertexAttributeTimeStep(
+    modelId: string,
+    blockIds: string[],
+    timeStep: number,
+  ): Promise<void> {
+    const name = modelBlocksVertexAttributeName(modelId, blockIds[0]);
+    if (name === undefined) {
+      return;
+    }
+    await setAttributeTimeStep(modelId, attributeSchema.$id, name, timeStep);
+    await Promise.all([
+      applyVertexAttribute(modelId, blockIds),
+      reapplySameSeries(
+        await dataStore.getBlocksGeodeIds(modelId),
+        blockIds,
+        (id) =>
+          modelBlocksCommonStyle.modelBlockColoring(modelId, id).active === "vertex" &&
+          modelBlocksVertexAttributeName(modelId, id) === name
+            ? [
+                modelBlocksVertexAttributeItem(modelId, id),
+                modelBlocksVertexAttributeRange(modelId, id),
+                modelBlocksVertexAttributeColorMap(modelId, id),
+                JSON.stringify(modelBlocksVertexAttributeNoDataColor(modelId, id)),
+              ].join("|")
+            : undefined,
+        async (ids) => {
+          await applyVertexAttribute(modelId, ids);
+        },
+      ),
+    ]);
+  }
   async function setModelBlocksVertexAttributeRange(
     modelId: string,
     blockIds: string[],
@@ -314,12 +372,6 @@ function useModelBlocksVertexAttribute(): UseModelBlocksVertexAttributeReturn {
     });
     return applyVertexAttribute(modelId, blockIds);
   }
-  function modelBlocksVertexAttributeNoDataColor(modelId: string, blockId?: string): RGBAColor {
-    const name = modelBlocksVertexAttributeName(modelId, blockId);
-    const item = modelBlocksVertexAttributeItem(modelId, blockId);
-    const storedConfig = modelBlocksVertexAttributeStoredConfig(modelId, blockId, name, item);
-    return storedConfig.no_data_color;
-  }
   async function setModelBlocksVertexAttributeNoDataColor(
     modelId: string,
     blockIds: string[],
@@ -336,6 +388,8 @@ function useModelBlocksVertexAttribute(): UseModelBlocksVertexAttributeReturn {
   }
   return {
     modelBlocksVertexAttributeName,
+    modelBlocksVertexAttributeTimeStep,
+    setModelBlocksVertexAttributeTimeStep,
     modelBlocksVertexAttributeItem,
     modelBlocksVertexAttributeRange,
     modelBlocksVertexAttributeColorMap,

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

@@ -102,7 +102,11 @@ export function useModelCornersColor(): ModelCornersColorApi {
         modelId,
         corners_ids[0],
       );
-      const attribute = { name, item, minimum, maximum, colorMap };
+      const no_data_color = modelCornersVertexAttribute.modelCornersVertexAttributeNoDataColor(
+        modelId,
+        corners_ids[0],
+      );
+      const attribute = { name, item, minimum, maximum, colorMap, no_data_color };
       if (isModelCornersVertexAttributeValid(attribute)) {
         return modelCornersVertexAttribute.setModelCornersVertexAttribute(
           modelId,

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

@@ -16,6 +16,7 @@ interface AttributeGroup {
   minimum: number;
   maximum: number;
   colorMap: string;
+  no_data_color?: RGBAColor;
   corners_ids: string[];
 }
 
@@ -118,17 +119,30 @@ export function useModelCornersStyle(): ModelCornersStyleApi {
             modelId,
             corner_id,
           );
-          const attribute = { name, item, minimum, maximum, colorMap };
+          const no_data_color = modelCornersVertexAttribute.modelCornersVertexAttributeNoDataColor(
+            modelId,
+            corner_id,
+          );
+          const attribute = {
+            name,
+            item,
+            minimum,
+            maximum,
+            colorMap,
+            no_data_color,
+          };
           if (!isModelCornersVertexAttributeValid(attribute)) {
             continue;
           }
-          const key = `${name}_${item}_${colorMap}_${minimum}_${maximum}`;
+          const key = [name, item, colorMap, minimum, maximum, JSON.stringify(no_data_color)].join(
+            "_",
+          );
           vertexGroups[key] ??= { ...attribute, corners_ids: [] };
           vertexGroups[key].corners_ids.push(corner_id);
         }
         coloringPromises.push(
           ...Object.values(vertexGroups).map(
-            async ({ name, item, minimum, maximum, colorMap, corners_ids: ids }) => {
+            async ({ name, item, minimum, maximum, colorMap, no_data_color, corners_ids: ids }) => {
               const result = await modelCornersVertexAttribute.setModelCornersVertexAttribute(
                 modelId,
                 ids,
@@ -138,6 +152,7 @@ export function useModelCornersStyle(): ModelCornersStyleApi {
                   minimum,
                   maximum,
                   colorMap,
+                  no_data_color,
                 },
               );
               return result;

package/internal/stores/data_style/model/corners/vertex.ts

@@ -1,8 +1,13 @@
+// oxlint-disable eslint/max-lines
 import { DEFAULT_NO_DATA_COLOR, type RGBAColor } from "@ogw_front/utils/default_styles/constants";
 // Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 
 // Local imports
+import {
+  reapplySameSeries,
+  useAttributeTimeStepStyle,
+} from "@ogw_internal/stores/data_style/time_step";
 import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useModelCornersCommonStyle } from "./common";
@@ -51,6 +56,12 @@ interface ModelCornersVertexAttributeApi {
     modelId: string,
     cornerId?: string,
   ) => [number | undefined, number | undefined];
+  modelCornersVertexAttributeTimeStep: (modelId: string, cornerId?: string) => number | undefined;
+  setModelCornersVertexAttributeTimeStep: (
+    modelId: string,
+    cornerIds: string[],
+    timeStep: number,
+  ) => Promise<void>;
   modelCornersVertexAttributeColorMap: (modelId: string, cornerId?: string) => string | undefined;
   modelCornersVertexAttributeStoredConfig: (
     modelId: string,
@@ -88,6 +99,7 @@ function isModelCornersVertexAttributeValid(input: AttributeInput): input is Val
 
 // oxlint-disable-next-line max-lines-per-function
 function useModelCornersVertexAttribute(): ModelCornersVertexAttributeApi {
+  const { attributeTimeStep, setAttributeTimeStep, seriesArrayName } = useAttributeTimeStepStyle();
   const dataStore = useDataStore();
   const modelCornersCommonStyle = useModelCornersCommonStyle();
   const viewerStore = useViewerStore();
@@ -128,7 +140,9 @@ function useModelCornersVertexAttribute(): ModelCornersVertexAttributeApi {
     const totalCornerIds = await dataStore.getCornersGeodeIds(modelId);
     if (cornerIds.length === totalCornerIds.length) {
       tasks.push(
-        modelCornersCommonStyle.mutateModelCornersTypeColoring(modelId, { vertex: values }),
+        modelCornersCommonStyle.mutateModelCornersTypeColoring(modelId, {
+          vertex: values,
+        }),
       );
     }
     await Promise.all(tasks);
@@ -190,6 +204,21 @@ function useModelCornersVertexAttribute(): ModelCornersVertexAttributeApi {
     const item = modelCornersVertexAttributeItem(modelId, cornerId);
     return modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item).colorMap;
   }
+  function modelCornersVertexAttributeNoDataColor(modelId: string, cornerId?: string): RGBAColor {
+    const name = modelCornersVertexAttributeName(modelId, cornerId);
+    const item = modelCornersVertexAttributeItem(modelId, cornerId);
+    return modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item).no_data_color;
+  }
+  function modelCornersVertexAttributeTimeStep(
+    modelId: string,
+    cornerId?: string,
+  ): number | undefined {
+    return attributeTimeStep(
+      modelId,
+      attributeSchema.$id,
+      modelCornersVertexAttribute(modelId, cornerId).name,
+    );
+  }
   async function setModelCornersVertexAttribute(
     modelId: string,
     cornerIds: string[],
@@ -214,14 +243,17 @@ function useModelCornersVertexAttribute(): ModelCornersVertexAttributeApi {
     const params = {
       id: modelId,
       block_ids: corner_viewer_ids,
-      name,
+      name: seriesArrayName(modelId, attributeSchema.$id, name),
       item,
       points,
       minimum,
       maximum,
       no_data_color,
     };
-    const result = await viewerStore.request({ schema: attributeSchema, params });
+    const result = await viewerStore.request({
+      schema: attributeSchema,
+      params,
+    });
     return result;
   }
   async function applyVertexAttribute(modelId: string, cornerIds: string[]): Promise<void> {
@@ -257,6 +289,37 @@ function useModelCornersVertexAttribute(): ModelCornersVertexAttributeApi {
     await mutateModelCornersVertexStyle(modelId, cornerIds, { item });
     await applyVertexAttribute(modelId, cornerIds);
   }
+  async function setModelCornersVertexAttributeTimeStep(
+    modelId: string,
+    cornerIds: string[],
+    timeStep: number,
+  ): Promise<void> {
+    const name = modelCornersVertexAttributeName(modelId, cornerIds[0]);
+    if (name === undefined) {
+      return;
+    }
+    await setAttributeTimeStep(modelId, attributeSchema.$id, name, timeStep);
+    await Promise.all([
+      applyVertexAttribute(modelId, cornerIds),
+      reapplySameSeries(
+        await dataStore.getCornersGeodeIds(modelId),
+        cornerIds,
+        (id) =>
+          modelCornersCommonStyle.modelCornerColoring(modelId, id).active === "vertex" &&
+          modelCornersVertexAttributeName(modelId, id) === name
+            ? [
+                modelCornersVertexAttributeItem(modelId, id),
+                modelCornersVertexAttributeRange(modelId, id),
+                modelCornersVertexAttributeColorMap(modelId, id),
+                JSON.stringify(modelCornersVertexAttributeNoDataColor(modelId, id)),
+              ].join("|")
+            : undefined,
+        async (ids) => {
+          await applyVertexAttribute(modelId, ids);
+        },
+      ),
+    ]);
+  }
   async function setModelCornersVertexAttributeRange(
     modelId: string,
     cornerIds: string[],
@@ -281,11 +344,6 @@ function useModelCornersVertexAttribute(): ModelCornersVertexAttributeApi {
     await setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, { colorMap });
     await applyVertexAttribute(modelId, cornerIds);
   }
-  function modelCornersVertexAttributeNoDataColor(modelId: string, cornerId?: string): RGBAColor {
-    const name = modelCornersVertexAttributeName(modelId, cornerId);
-    const item = modelCornersVertexAttributeItem(modelId, cornerId);
-    return modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item).no_data_color;
-  }
   async function setModelCornersVertexAttributeNoDataColor(
     modelId: string,
     cornerIds: string[],
@@ -302,6 +360,8 @@ function useModelCornersVertexAttribute(): ModelCornersVertexAttributeApi {
   }
   return {
     modelCornersVertexAttributeName,
+    modelCornersVertexAttributeTimeStep,
+    setModelCornersVertexAttributeTimeStep,
     modelCornersVertexAttributeItem,
     modelCornersVertexAttributeRange,
     modelCornersVertexAttributeColorMap,

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

@@ -96,7 +96,11 @@ export function useModelLinesColor(): {
         modelId,
         lines_ids[0],
       );
-      const attribute = { name, item, minimum, maximum, colorMap };
+      const no_data_color = modelLinesVertexAttribute.modelLinesVertexAttributeNoDataColor(
+        modelId,
+        lines_ids[0],
+      );
+      const attribute = { name, item, minimum, maximum, colorMap, no_data_color };
       if (isModelLinesVertexAttributeValid(attribute)) {
         return modelLinesVertexAttribute.setModelLinesVertexAttribute(
           modelId,
@@ -115,7 +119,11 @@ export function useModelLinesColor(): {
         modelId,
         lines_ids[0],
       );
-      const attribute = { name, item, minimum, maximum, colorMap };
+      const no_data_color = modelLinesEdgeAttribute.modelLinesEdgeAttributeNoDataColor(
+        modelId,
+        lines_ids[0],
+      );
+      const attribute = { name, item, minimum, maximum, colorMap, no_data_color };
       if (isModelLinesEdgeAttributeValid(attribute)) {
         return modelLinesEdgeAttribute.setModelLinesEdgeAttribute(modelId, lines_ids, attribute);
       }

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

@@ -4,6 +4,10 @@ import { DEFAULT_NO_DATA_COLOR, type RGBAColor } from "@ogw_front/utils/default_
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 
 // Local imports
+import {
+  reapplySameSeries,
+  useAttributeTimeStepStyle,
+} from "@ogw_internal/stores/data_style/time_step";
 import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useModelLinesCommonStyle } from "./common";
@@ -60,6 +64,12 @@ interface UseModelLinesEdgeAttributeReturn {
     modelId: string,
     lineId?: string,
   ) => [number | undefined, number | undefined];
+  modelLinesEdgeAttributeTimeStep: (modelId: string, lineId?: string) => number | undefined;
+  setModelLinesEdgeAttributeTimeStep: (
+    modelId: string,
+    lineIds: string[],
+    timeStep: number,
+  ) => Promise<void>;
   modelLinesEdgeAttributeColorMap: (modelId: string, lineId?: string) => string | undefined;
   modelLinesEdgeAttributeStoredConfig: (
     modelId: string,
@@ -103,6 +113,7 @@ interface UseModelLinesEdgeAttributeReturn {
 
 // oxlint-disable-next-line max-lines-per-function
 function useModelLinesEdgeAttribute(): UseModelLinesEdgeAttributeReturn {
+  const { attributeTimeStep, setAttributeTimeStep, seriesArrayName } = useAttributeTimeStepStyle();
   const dataStore = useDataStore();
   const modelLinesCommonStyle = useModelLinesCommonStyle();
   const viewerStore = useViewerStore();
@@ -205,6 +216,19 @@ function useModelLinesEdgeAttribute(): UseModelLinesEdgeAttributeReturn {
     const storedConfig = modelLinesEdgeAttributeStoredConfig(modelId, lineId, name, item);
     return storedConfig.colorMap;
   }
+  function modelLinesEdgeAttributeNoDataColor(modelId: string, lineId?: string): RGBAColor {
+    const name = modelLinesEdgeAttributeName(modelId, lineId);
+    const item = modelLinesEdgeAttributeItem(modelId, lineId);
+    const storedConfig = modelLinesEdgeAttributeStoredConfig(modelId, lineId, name, item);
+    return storedConfig.no_data_color;
+  }
+  function modelLinesEdgeAttributeTimeStep(modelId: string, lineId?: string): number | undefined {
+    return attributeTimeStep(
+      modelId,
+      attributeSchema.$id,
+      modelLinesEdgeAttribute(modelId, lineId).name,
+    );
+  }
   async function setModelLinesEdgeAttribute(
     modelId: string,
     lineIds: string[],
@@ -232,7 +256,7 @@ function useModelLinesEdgeAttribute(): UseModelLinesEdgeAttributeReturn {
     const params = {
       id: modelId,
       block_ids: line_viewer_ids,
-      name,
+      name: seriesArrayName(modelId, attributeSchema.$id, name),
       item,
       points,
       minimum,
@@ -282,6 +306,37 @@ function useModelLinesEdgeAttribute(): UseModelLinesEdgeAttributeReturn {
     });
     return applyEdgeAttribute(modelId, lineIds);
   }
+  async function setModelLinesEdgeAttributeTimeStep(
+    modelId: string,
+    lineIds: string[],
+    timeStep: number,
+  ): Promise<void> {
+    const name = modelLinesEdgeAttributeName(modelId, lineIds[0]);
+    if (name === undefined) {
+      return;
+    }
+    await setAttributeTimeStep(modelId, attributeSchema.$id, name, timeStep);
+    await Promise.all([
+      applyEdgeAttribute(modelId, lineIds),
+      reapplySameSeries(
+        await dataStore.getLinesGeodeIds(modelId),
+        lineIds,
+        (id) =>
+          modelLinesCommonStyle.modelLineColoring(modelId, id).active === "edge" &&
+          modelLinesEdgeAttributeName(modelId, id) === name
+            ? [
+                modelLinesEdgeAttributeItem(modelId, id),
+                modelLinesEdgeAttributeRange(modelId, id),
+                modelLinesEdgeAttributeColorMap(modelId, id),
+                JSON.stringify(modelLinesEdgeAttributeNoDataColor(modelId, id)),
+              ].join("|")
+            : undefined,
+        async (ids) => {
+          await applyEdgeAttribute(modelId, ids);
+        },
+      ),
+    ]);
+  }
   async function setModelLinesEdgeAttributeRange(
     modelId: string,
     lineIds: string[],
@@ -308,12 +363,6 @@ function useModelLinesEdgeAttribute(): UseModelLinesEdgeAttributeReturn {
     });
     return applyEdgeAttribute(modelId, lineIds);
   }
-  function modelLinesEdgeAttributeNoDataColor(modelId: string, lineId?: string): RGBAColor {
-    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[],
@@ -330,6 +379,8 @@ function useModelLinesEdgeAttribute(): UseModelLinesEdgeAttributeReturn {
   }
   return {
     modelLinesEdgeAttributeName,
+    modelLinesEdgeAttributeTimeStep,
+    setModelLinesEdgeAttributeTimeStep,
     modelLinesEdgeAttributeItem,
     modelLinesEdgeAttributeRange,
     modelLinesEdgeAttributeColorMap,

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

@@ -17,6 +17,7 @@ interface AttributeGroup {
   minimum: number;
   maximum: number;
   colorMap: string;
+  no_data_color?: RGBAColor;
   lines_ids: string[];
 }
 
@@ -113,17 +114,30 @@ export function useModelLinesStyle(): ReturnType<typeof useModelLinesCommonStyle
             modelId,
             line_id,
           );
-          const attribute = { name, item, minimum, maximum, colorMap };
+          const no_data_color = modelLinesVertexAttribute.modelLinesVertexAttributeNoDataColor(
+            modelId,
+            line_id,
+          );
+          const attribute = {
+            name,
+            item,
+            minimum,
+            maximum,
+            colorMap,
+            no_data_color,
+          };
           if (!isModelLinesVertexAttributeValid(attribute)) {
             continue;
           }
-          const key = `${name}_${item}_${colorMap}_${minimum}_${maximum}`;
+          const key = [name, item, colorMap, minimum, maximum, JSON.stringify(no_data_color)].join(
+            "_",
+          );
           vertexGroups[key] ??= { ...attribute, lines_ids: [] };
           vertexGroups[key].lines_ids.push(line_id);
         }
         coloringPromises.push(
           ...Object.values(vertexGroups).map(
-            async ({ name, item, minimum, maximum, colorMap, lines_ids: ids }) => {
+            async ({ name, item, minimum, maximum, colorMap, no_data_color, lines_ids: ids }) => {
               const result = await modelLinesVertexAttribute.setModelLinesVertexAttribute(
                 modelId,
                 ids,
@@ -133,6 +147,7 @@ export function useModelLinesStyle(): ReturnType<typeof useModelLinesCommonStyle
                   minimum,
                   maximum,
                   colorMap,
+                  no_data_color,
                 },
               );
               return result;
@@ -152,17 +167,30 @@ export function useModelLinesStyle(): ReturnType<typeof useModelLinesCommonStyle
             modelId,
             line_id,
           );
-          const attribute = { name, item, minimum, maximum, colorMap };
+          const no_data_color = modelLinesEdgeAttribute.modelLinesEdgeAttributeNoDataColor(
+            modelId,
+            line_id,
+          );
+          const attribute = {
+            name,
+            item,
+            minimum,
+            maximum,
+            colorMap,
+            no_data_color,
+          };
           if (!isModelLinesEdgeAttributeValid(attribute)) {
             continue;
           }
-          const key = `${name}_${item}_${colorMap}_${minimum}_${maximum}`;
+          const key = [name, item, colorMap, minimum, maximum, JSON.stringify(no_data_color)].join(
+            "_",
+          );
           edgeGroups[key] ??= { ...attribute, lines_ids: [] };
           edgeGroups[key].lines_ids.push(line_id);
         }
         coloringPromises.push(
           ...Object.values(edgeGroups).map(
-            async ({ name, item, minimum, maximum, colorMap, lines_ids: ids }) => {
+            async ({ name, item, minimum, maximum, colorMap, no_data_color, lines_ids: ids }) => {
               const result = await modelLinesEdgeAttribute.setModelLinesEdgeAttribute(
                 modelId,
                 ids,
@@ -172,6 +200,7 @@ export function useModelLinesStyle(): ReturnType<typeof useModelLinesCommonStyle
                   minimum,
                   maximum,
                   colorMap,
+                  no_data_color,
                 },
               );
               return result;

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

@@ -4,6 +4,10 @@ import { DEFAULT_NO_DATA_COLOR, type RGBAColor } from "@ogw_front/utils/default_
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 
 // Local imports
+import {
+  reapplySameSeries,
+  useAttributeTimeStepStyle,
+} from "@ogw_internal/stores/data_style/time_step";
 import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useModelLinesCommonStyle } from "./common";
@@ -60,6 +64,12 @@ interface UseModelLinesVertexAttributeReturn {
     modelId: string,
     lineId?: string,
   ) => [number | undefined, number | undefined];
+  modelLinesVertexAttributeTimeStep: (modelId: string, lineId?: string) => number | undefined;
+  setModelLinesVertexAttributeTimeStep: (
+    modelId: string,
+    lineIds: string[],
+    timeStep: number,
+  ) => Promise<void>;
   modelLinesVertexAttributeColorMap: (modelId: string, lineId?: string) => string | undefined;
   modelLinesVertexAttributeStoredConfig: (
     modelId: string,
@@ -103,6 +113,7 @@ interface UseModelLinesVertexAttributeReturn {
 
 // oxlint-disable-next-line max-lines-per-function
 function useModelLinesVertexAttribute(): UseModelLinesVertexAttributeReturn {
+  const { attributeTimeStep, setAttributeTimeStep, seriesArrayName } = useAttributeTimeStepStyle();
   const dataStore = useDataStore();
   const modelLinesCommonStyle = useModelLinesCommonStyle();
   const viewerStore = useViewerStore();
@@ -206,6 +217,19 @@ function useModelLinesVertexAttribute(): UseModelLinesVertexAttributeReturn {
     const storedConfig = modelLinesVertexAttributeStoredConfig(modelId, lineId, name, item);
     return storedConfig.colorMap;
   }
+  function modelLinesVertexAttributeNoDataColor(modelId: string, lineId?: string): RGBAColor {
+    const name = modelLinesVertexAttributeName(modelId, lineId);
+    const item = modelLinesVertexAttributeItem(modelId, lineId);
+    const storedConfig = modelLinesVertexAttributeStoredConfig(modelId, lineId, name, item);
+    return storedConfig.no_data_color;
+  }
+  function modelLinesVertexAttributeTimeStep(modelId: string, lineId?: string): number | undefined {
+    return attributeTimeStep(
+      modelId,
+      attributeSchema.$id,
+      modelLinesVertexAttribute(modelId, lineId).name,
+    );
+  }
   async function setModelLinesVertexAttribute(
     modelId: string,
     lineIds: string[],
@@ -233,7 +257,7 @@ function useModelLinesVertexAttribute(): UseModelLinesVertexAttributeReturn {
     const params = {
       id: modelId,
       block_ids: line_viewer_ids,
-      name,
+      name: seriesArrayName(modelId, attributeSchema.$id, name),
       item,
       points,
       minimum,
@@ -283,6 +307,37 @@ function useModelLinesVertexAttribute(): UseModelLinesVertexAttributeReturn {
     });
     return applyVertexAttribute(modelId, lineIds);
   }
+  async function setModelLinesVertexAttributeTimeStep(
+    modelId: string,
+    lineIds: string[],
+    timeStep: number,
+  ): Promise<void> {
+    const name = modelLinesVertexAttributeName(modelId, lineIds[0]);
+    if (name === undefined) {
+      return;
+    }
+    await setAttributeTimeStep(modelId, attributeSchema.$id, name, timeStep);
+    await Promise.all([
+      applyVertexAttribute(modelId, lineIds),
+      reapplySameSeries(
+        await dataStore.getLinesGeodeIds(modelId),
+        lineIds,
+        (id) =>
+          modelLinesCommonStyle.modelLineColoring(modelId, id).active === "vertex" &&
+          modelLinesVertexAttributeName(modelId, id) === name
+            ? [
+                modelLinesVertexAttributeItem(modelId, id),
+                modelLinesVertexAttributeRange(modelId, id),
+                modelLinesVertexAttributeColorMap(modelId, id),
+                JSON.stringify(modelLinesVertexAttributeNoDataColor(modelId, id)),
+              ].join("|")
+            : undefined,
+        async (ids) => {
+          await applyVertexAttribute(modelId, ids);
+        },
+      ),
+    ]);
+  }
   async function setModelLinesVertexAttributeRange(
     modelId: string,
     lineIds: string[],
@@ -309,12 +364,6 @@ function useModelLinesVertexAttribute(): UseModelLinesVertexAttributeReturn {
     });
     return applyVertexAttribute(modelId, lineIds);
   }
-  function modelLinesVertexAttributeNoDataColor(modelId: string, lineId?: string): RGBAColor {
-    const name = modelLinesVertexAttributeName(modelId, lineId);
-    const item = modelLinesVertexAttributeItem(modelId, lineId);
-    const storedConfig = modelLinesVertexAttributeStoredConfig(modelId, lineId, name, item);
-    return storedConfig.no_data_color;
-  }
   async function setModelLinesVertexAttributeNoDataColor(
     modelId: string,
     lineIds: string[],
@@ -331,6 +380,8 @@ function useModelLinesVertexAttribute(): UseModelLinesVertexAttributeReturn {
   }
   return {
     modelLinesVertexAttributeName,
+    modelLinesVertexAttributeTimeStep,
+    setModelLinesVertexAttributeTimeStep,
     modelLinesVertexAttributeItem,
     modelLinesVertexAttributeRange,
     modelLinesVertexAttributeColorMap,