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

package/internal/stores/data_style/mesh/cells/vertex.ts

@@ -0,0 +1,285 @@
+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 { useMeshCellsCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
+
+// Local constants
+const meshCellsVertexAttributeSchemas =
+  viewer_schemas.opengeodeweb_viewer.mesh.cells.attribute.vertex;
+
+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 isMeshCellsVertexAttributeValid({
+  name,
+  item,
+  minimum,
+  maximum,
+  colorMap,
+}: AttributeInput): boolean {
+  return (
+    name !== undefined &&
+    item !== undefined &&
+    minimum !== undefined &&
+    maximum !== undefined &&
+    colorMap !== undefined
+  );
+}
+
+interface UseMeshCellsVertexAttributeStyleReturn {
+  meshCellsVertexAttributeName: (id: string) => string | undefined;
+  meshCellsVertexAttributeItem: (id: string) => number;
+  meshCellsVertexAttributeRange: (id: string) => [number | undefined, number | undefined];
+  meshCellsVertexAttributeColorMap: (id: string) => string | undefined;
+  meshCellsVertexAttributeStoredConfig: (
+    id: string,
+    name: string | undefined,
+    item: number | undefined,
+  ) => AttributeStoredConfig;
+  setMeshCellsVertexAttribute: (id: string, input: AttributeInput) => Promise<unknown>;
+  setMeshCellsVertexAttributeName: (id: string, name: string) => Promise<unknown>;
+  setMeshCellsVertexAttributeItem: (id: string, item: number) => Promise<unknown>;
+  setMeshCellsVertexAttributeRange: (
+    id: string,
+    minimum: number,
+    maximum: number,
+  ) => Promise<unknown>;
+  setMeshCellsVertexAttributeColorMap: (
+    id: string,
+    colorMap: string | undefined,
+  ) => Promise<unknown>;
+  meshCellsVertexAttributeNoDataColor: (id: string) => unknown;
+  setMeshCellsVertexAttributeNoDataColor: (id: string, no_data_color: unknown) => Promise<unknown>;
+}
+
+// oxlint-disable-next-line max-lines-per-function
+function useMeshCellsVertexAttributeStyle(): UseMeshCellsVertexAttributeStyleReturn {
+  const viewerStore = useViewerStore();
+  const meshCellsCommonStyle = useMeshCellsCommonStyle();
+  function meshCellsVertexAttribute(id: string): AttributeState {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring.vertex shape is defined by the data style schema.
+    return meshCellsCommonStyle.meshCellsColoring(id).vertex as AttributeState;
+  }
+  function meshCellsVertexAttributeStoredConfig(
+    id: string,
+    name: string | undefined,
+    item: number | undefined,
+  ): AttributeStoredConfig {
+    const { storedConfigs } = meshCellsVertexAttribute(id);
+    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 mutateMeshCellsVertexStyle(
+    id: string,
+    values: Record<string, unknown>,
+  ): Promise<string> {
+    const result = await meshCellsCommonStyle.mutateMeshCellsStyle(id, {
+      coloring: {
+        vertex: values,
+      },
+    });
+    return result;
+  }
+  async function setMeshCellsVertexAttributeStoredConfig(
+    id: string,
+    name: string | undefined,
+    item: number | undefined,
+    config: Partial<AttributeStoredConfig>,
+  ): Promise<string> {
+    const result = await mutateMeshCellsVertexStyle(id, {
+      storedConfigs: {
+        [name ?? ""]: {
+          lastItem: item,
+          [item ?? 0]: config,
+        },
+      },
+    });
+    return result;
+  }
+  function meshCellsVertexAttributeName(id: string): string | undefined {
+    return meshCellsVertexAttribute(id).name;
+  }
+  function meshCellsVertexAttributeLastItem(id: string, name: string | undefined): number {
+    const { storedConfigs } = meshCellsVertexAttribute(id);
+    const nameConfig = name === undefined ? undefined : storedConfigs?.[name];
+    if (nameConfig !== undefined) {
+      return nameConfig.lastItem;
+    }
+    return 0;
+  }
+  function meshCellsVertexAttributeItem(id: string): number {
+    const { item, name } = meshCellsVertexAttribute(id);
+    return item ?? meshCellsVertexAttributeLastItem(id, name);
+  }
+  async function setMeshCellsVertexAttribute(
+    id: string,
+    {
+      name,
+      item,
+      minimum,
+      maximum,
+      colorMap,
+      no_data_color = DEFAULT_NO_DATA_COLOR,
+    }: AttributeInput,
+  ): Promise<unknown> {
+    await mutateMeshCellsVertexStyle(id, {
+      name,
+      item,
+    });
+    await setMeshCellsVertexAttributeStoredConfig(id, name, item, {
+      minimum,
+      maximum,
+      colorMap,
+      no_data_color,
+    });
+    const points = getRGBPointsFromPreset(colorMap ?? "");
+    const schema = meshCellsVertexAttributeSchemas.attribute;
+    const params = {
+      id,
+      name,
+      item,
+      points,
+      minimum,
+      maximum,
+      no_data_color,
+    };
+    return viewerStore.request({
+      schema,
+      params,
+    });
+  }
+  async function applyVertexAttribute(id: string): Promise<unknown> {
+    const name = meshCellsVertexAttributeName(id);
+    const item = meshCellsVertexAttributeItem(id);
+    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name, item);
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+      no_data_color: storedConfig.no_data_color,
+    };
+    if (isMeshCellsVertexAttributeValid(attribute)) {
+      const result = await setMeshCellsVertexAttribute(id, attribute);
+      return result;
+    }
+    return undefined;
+  }
+  async function setMeshCellsVertexAttributeName(id: string, name: string): Promise<unknown> {
+    const item = meshCellsVertexAttributeLastItem(id, name);
+    await mutateMeshCellsVertexStyle(id, {
+      name,
+      item,
+    });
+    return applyVertexAttribute(id);
+  }
+  async function setMeshCellsVertexAttributeItem(id: string, item: number): Promise<unknown> {
+    await mutateMeshCellsVertexStyle(id, {
+      item,
+    });
+    return applyVertexAttribute(id);
+  }
+  function meshCellsVertexAttributeRange(id: string): [number | undefined, number | undefined] {
+    const name = meshCellsVertexAttributeName(id);
+    const item = meshCellsVertexAttributeItem(id);
+    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name, item);
+    return [storedConfig.minimum, storedConfig.maximum];
+  }
+  async function setMeshCellsVertexAttributeRange(
+    id: string,
+    minimum: number,
+    maximum: number,
+  ): Promise<unknown> {
+    const name = meshCellsVertexAttributeName(id);
+    const item = meshCellsVertexAttributeItem(id);
+    await setMeshCellsVertexAttributeStoredConfig(id, name, item, {
+      minimum,
+      maximum,
+    });
+    return applyVertexAttribute(id);
+  }
+  function meshCellsVertexAttributeColorMap(id: string): string | undefined {
+    const name = meshCellsVertexAttributeName(id);
+    const item = meshCellsVertexAttributeItem(id);
+    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name, item);
+    return storedConfig.colorMap;
+  }
+  async function setMeshCellsVertexAttributeColorMap(
+    id: string,
+    colorMap: string | undefined,
+  ): Promise<unknown> {
+    const name = meshCellsVertexAttributeName(id);
+    const item = meshCellsVertexAttributeItem(id);
+    await setMeshCellsVertexAttributeStoredConfig(id, name, item, {
+      colorMap,
+    });
+    return applyVertexAttribute(id);
+  }
+  function meshCellsVertexAttributeNoDataColor(id: string): unknown {
+    const name = meshCellsVertexAttributeName(id);
+    const item = meshCellsVertexAttributeItem(id);
+    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name, item);
+    return storedConfig.no_data_color;
+  }
+  async function setMeshCellsVertexAttributeNoDataColor(
+    id: string,
+    no_data_color: unknown,
+  ): Promise<unknown> {
+    const name = meshCellsVertexAttributeName(id);
+    const item = meshCellsVertexAttributeItem(id);
+    const storedConfig = meshCellsVertexAttributeStoredConfig(id, name, item);
+    await setMeshCellsVertexAttributeStoredConfig(id, name, item, {
+      ...storedConfig,
+      no_data_color,
+    });
+    return applyVertexAttribute(id);
+  }
+  return {
+    meshCellsVertexAttributeName,
+    meshCellsVertexAttributeItem,
+    meshCellsVertexAttributeRange,
+    meshCellsVertexAttributeColorMap,
+    meshCellsVertexAttributeStoredConfig,
+    setMeshCellsVertexAttribute,
+    setMeshCellsVertexAttributeName,
+    setMeshCellsVertexAttributeItem,
+    setMeshCellsVertexAttributeRange,
+    setMeshCellsVertexAttributeColorMap,
+    meshCellsVertexAttributeNoDataColor,
+    setMeshCellsVertexAttributeNoDataColor,
+  };
+}
+export { isMeshCellsVertexAttributeValid, useMeshCellsVertexAttributeStyle };

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

@@ -0,0 +1,46 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
+
+// Local imports
+import { useMeshCellsCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
+
+// Local constants
+const schema = viewer_schemas.opengeodeweb_viewer.mesh.cells.visibility;
+
+export function useMeshCellsVisibilityStyle(): {
+  meshCellsVisibility: (id: string) => boolean | undefined;
+  setMeshCellsVisibility: (id: string, visibility: boolean | undefined) => Promise<unknown>;
+} {
+  const viewerStore = useViewerStore();
+  const meshCellsCommonStyle = useMeshCellsCommonStyle();
+
+  function meshCellsVisibility(id: string): boolean | undefined {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- visibility is defined as boolean in the data style schema.
+    return meshCellsCommonStyle.meshCellsStyle(id).visibility as boolean | undefined;
+  }
+  async function setMeshCellsVisibility(
+    id: string,
+    visibility: boolean | undefined,
+  ): Promise<unknown> {
+    const params = { id, visibility };
+    const result = await viewerStore.request(
+      {
+        schema,
+        params,
+      },
+      {
+        response_function: async () => {
+          const mutateResult = await meshCellsCommonStyle.mutateMeshCellsStyle(id, { visibility });
+          return mutateResult;
+        },
+      },
+    );
+    return result;
+  }
+
+  return {
+    meshCellsVisibility,
+    setMeshCellsVisibility,
+  };
+}

package/internal/stores/data_style/mesh/edges/{color.js → color.ts}

@@ -8,27 +8,33 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const schema = viewer_schemas.opengeodeweb_viewer.mesh.edges.color;
 
-export function useMeshEdgesColorStyle() {
+export function useMeshEdgesColorStyle(): {
+  meshEdgesColor: (id: string) => unknown;
+  setMeshEdgesColor: (id: string, color: unknown) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
 
-  function meshEdgesColor(id) {
+  function meshEdgesColor(id: string): unknown {
     return meshEdgesCommonStyle.meshEdgesColoring(id).constant;
   }
-  function setMeshEdgesColor(id, color) {
+  async function setMeshEdgesColor(id: string, color: unknown): Promise<unknown> {
     const params = { id, color };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
-        response_function: () =>
-          meshEdgesCommonStyle.mutateMeshEdgesColoring(id, {
+        response_function: async () => {
+          const mutateResult = await meshEdgesCommonStyle.mutateMeshEdgesColoring(id, {
             constant: color,
-          }),
+          });
+          return mutateResult;
+        },
       },
     );
+    return result;
   }
 
   return {

package/internal/stores/data_style/mesh/edges/common.ts

@@ -0,0 +1,41 @@
+import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
+import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
+
+export function useMeshEdgesCommonStyle(): {
+  meshEdgesStyle: (id: string) => StyleValues;
+  meshEdgesColoring: (id: string) => StyleValues;
+  mutateMeshEdgesStyle: (id: string, values: StyleValues) => Promise<string>;
+  mutateMeshEdgesColoring: (id: string, values: StyleValues) => Promise<string>;
+} {
+  const dataStyleState = useDataStyleState();
+
+  async function mutateMeshEdgesStyle(id: string, values: StyleValues): Promise<string> {
+    const result = await dataStyleState.mutateStyle(id, {
+      edges: values,
+    });
+    return result;
+  }
+
+  function meshEdgesStyle(id: string): StyleValues {
+    return dataStyleState.getStyle(id).edges ?? {};
+  }
+
+  function meshEdgesColoring(id: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring shape is defined by the data style schema.
+    return meshEdgesStyle(id).coloring as StyleValues;
+  }
+
+  async function mutateMeshEdgesColoring(id: string, values: StyleValues): Promise<string> {
+    const result = await mutateMeshEdgesStyle(id, {
+      coloring: values,
+    });
+    return result;
+  }
+
+  return {
+    meshEdgesStyle,
+    meshEdgesColoring,
+    mutateMeshEdgesStyle,
+    mutateMeshEdgesColoring,
+  };
+}

package/internal/stores/data_style/mesh/edges/edge.ts

@@ -0,0 +1,279 @@
+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 { useMeshEdgesCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
+
+// Local constants
+const meshEdgesEdgeAttributeSchemas = viewer_schemas.opengeodeweb_viewer.mesh.edges.attribute.edge;
+
+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 isMeshEdgesEdgeAttributeValid({
+  name,
+  item,
+  minimum,
+  maximum,
+  colorMap,
+}: AttributeInput): boolean {
+  return (
+    name !== undefined &&
+    item !== undefined &&
+    minimum !== undefined &&
+    maximum !== undefined &&
+    colorMap !== undefined
+  );
+}
+
+// oxlint-disable-next-line max-lines-per-function
+function useMeshEdgesEdgeAttributeStyle(): {
+  meshEdgesEdgeAttributeName: (id: string) => string | undefined;
+  meshEdgesEdgeAttributeItem: (id: string) => number;
+  meshEdgesEdgeAttributeRange: (id: string) => [number | undefined, number | undefined];
+  meshEdgesEdgeAttributeColorMap: (id: string) => string | undefined;
+  meshEdgesEdgeAttributeStoredConfig: (
+    id: string,
+    name: string | undefined,
+    item: number | undefined,
+  ) => AttributeStoredConfig;
+  setMeshEdgesEdgeAttribute: (id: string, input: AttributeInput) => Promise<unknown>;
+  setMeshEdgesEdgeAttributeName: (id: string, name: string) => Promise<unknown>;
+  setMeshEdgesEdgeAttributeItem: (id: string, item: number) => Promise<unknown>;
+  setMeshEdgesEdgeAttributeRange: (
+    id: string,
+    minimum: number,
+    maximum: number,
+  ) => Promise<unknown>;
+  setMeshEdgesEdgeAttributeColorMap: (id: string, colorMap: string | undefined) => Promise<unknown>;
+  meshEdgesEdgeAttributeNoDataColor: (id: string) => unknown;
+  setMeshEdgesEdgeAttributeNoDataColor: (id: string, no_data_color: unknown) => Promise<unknown>;
+} {
+  const viewerStore = useViewerStore();
+  const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
+  function meshEdgesEdgeAttribute(id: string): AttributeState {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring.edge shape is defined by the data style schema.
+    return meshEdgesCommonStyle.meshEdgesColoring(id).edge as AttributeState;
+  }
+  function meshEdgesEdgeAttributeStoredConfig(
+    id: string,
+    name: string | undefined,
+    item: number | undefined,
+  ): AttributeStoredConfig {
+    const { storedConfigs } = meshEdgesEdgeAttribute(id);
+    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 mutateMeshEdgesEdgeStyle(
+    id: string,
+    values: Record<string, unknown>,
+  ): Promise<string> {
+    const result = await meshEdgesCommonStyle.mutateMeshEdgesStyle(id, {
+      coloring: {
+        edge: values,
+      },
+    });
+    return result;
+  }
+  async function setMeshEdgesEdgeAttributeStoredConfig(
+    id: string,
+    name: string | undefined,
+    item: number | undefined,
+    config: Partial<AttributeStoredConfig>,
+  ): Promise<string> {
+    const result = await mutateMeshEdgesEdgeStyle(id, {
+      storedConfigs: {
+        [name ?? ""]: {
+          lastItem: item,
+          [item ?? 0]: config,
+        },
+      },
+    });
+    return result;
+  }
+  function meshEdgesEdgeAttributeName(id: string): string | undefined {
+    return meshEdgesEdgeAttribute(id).name;
+  }
+  function meshEdgesEdgeAttributeLastItem(id: string, name: string | undefined): number {
+    const { storedConfigs } = meshEdgesEdgeAttribute(id);
+    const nameConfig = name === undefined ? undefined : storedConfigs?.[name];
+    if (nameConfig !== undefined) {
+      return nameConfig.lastItem;
+    }
+    return 0;
+  }
+  function meshEdgesEdgeAttributeItem(id: string): number {
+    const { item, name } = meshEdgesEdgeAttribute(id);
+    return item ?? meshEdgesEdgeAttributeLastItem(id, name);
+  }
+  async function setMeshEdgesEdgeAttribute(
+    id: string,
+    {
+      name,
+      item,
+      minimum,
+      maximum,
+      colorMap,
+      no_data_color = DEFAULT_NO_DATA_COLOR,
+    }: AttributeInput,
+  ): Promise<unknown> {
+    await mutateMeshEdgesEdgeStyle(id, {
+      name,
+      item,
+    });
+    await setMeshEdgesEdgeAttributeStoredConfig(id, name, item, {
+      minimum,
+      maximum,
+      colorMap,
+      no_data_color,
+    });
+    const points = getRGBPointsFromPreset(colorMap ?? "");
+    const schema = meshEdgesEdgeAttributeSchemas.attribute;
+    const params = {
+      id,
+      name,
+      item,
+      points,
+      minimum,
+      maximum,
+      no_data_color,
+    };
+    return viewerStore.request({
+      schema,
+      params,
+    });
+  }
+  async function applyEdgeAttribute(id: string): Promise<unknown> {
+    const name = meshEdgesEdgeAttributeName(id);
+    const item = meshEdgesEdgeAttributeItem(id);
+    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name, item);
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+      no_data_color: storedConfig.no_data_color,
+    };
+    if (isMeshEdgesEdgeAttributeValid(attribute)) {
+      const result = await setMeshEdgesEdgeAttribute(id, attribute);
+      return result;
+    }
+    return undefined;
+  }
+  async function setMeshEdgesEdgeAttributeName(id: string, name: string): Promise<unknown> {
+    const item = meshEdgesEdgeAttributeLastItem(id, name);
+    await mutateMeshEdgesEdgeStyle(id, {
+      name,
+      item,
+    });
+    return applyEdgeAttribute(id);
+  }
+  async function setMeshEdgesEdgeAttributeItem(id: string, item: number): Promise<unknown> {
+    await mutateMeshEdgesEdgeStyle(id, {
+      item,
+    });
+    return applyEdgeAttribute(id);
+  }
+  function meshEdgesEdgeAttributeRange(id: string): [number | undefined, number | undefined] {
+    const name = meshEdgesEdgeAttributeName(id);
+    const item = meshEdgesEdgeAttributeItem(id);
+    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name, item);
+    return [storedConfig.minimum, storedConfig.maximum];
+  }
+  async function setMeshEdgesEdgeAttributeRange(
+    id: string,
+    minimum: number,
+    maximum: number,
+  ): Promise<unknown> {
+    const name = meshEdgesEdgeAttributeName(id);
+    const item = meshEdgesEdgeAttributeItem(id);
+    await setMeshEdgesEdgeAttributeStoredConfig(id, name, item, {
+      minimum,
+      maximum,
+    });
+    return applyEdgeAttribute(id);
+  }
+  function meshEdgesEdgeAttributeColorMap(id: string): string | undefined {
+    const name = meshEdgesEdgeAttributeName(id);
+    const item = meshEdgesEdgeAttributeItem(id);
+    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name, item);
+    return storedConfig.colorMap;
+  }
+  async function setMeshEdgesEdgeAttributeColorMap(
+    id: string,
+    colorMap: string | undefined,
+  ): Promise<unknown> {
+    const name = meshEdgesEdgeAttributeName(id);
+    const item = meshEdgesEdgeAttributeItem(id);
+    await setMeshEdgesEdgeAttributeStoredConfig(id, name, item, {
+      colorMap,
+    });
+    return applyEdgeAttribute(id);
+  }
+  function meshEdgesEdgeAttributeNoDataColor(id: string): unknown {
+    const name = meshEdgesEdgeAttributeName(id);
+    const item = meshEdgesEdgeAttributeItem(id);
+    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name, item);
+    return storedConfig.no_data_color;
+  }
+  async function setMeshEdgesEdgeAttributeNoDataColor(
+    id: string,
+    no_data_color: unknown,
+  ): Promise<unknown> {
+    const name = meshEdgesEdgeAttributeName(id);
+    const item = meshEdgesEdgeAttributeItem(id);
+    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name, item);
+    await setMeshEdgesEdgeAttributeStoredConfig(id, name, item, {
+      ...storedConfig,
+      no_data_color,
+    });
+    return applyEdgeAttribute(id);
+  }
+  return {
+    meshEdgesEdgeAttributeName,
+    meshEdgesEdgeAttributeItem,
+    meshEdgesEdgeAttributeRange,
+    meshEdgesEdgeAttributeColorMap,
+    meshEdgesEdgeAttributeStoredConfig,
+    setMeshEdgesEdgeAttribute,
+    setMeshEdgesEdgeAttributeName,
+    setMeshEdgesEdgeAttributeItem,
+    setMeshEdgesEdgeAttributeRange,
+    setMeshEdgesEdgeAttributeColorMap,
+    meshEdgesEdgeAttributeNoDataColor,
+    setMeshEdgesEdgeAttributeNoDataColor,
+  };
+}
+export { isMeshEdgesEdgeAttributeValid, useMeshEdgesEdgeAttributeStyle };