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

package/internal/stores/data_style/mesh/cells/cell.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 { useMeshCellsCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
+
+// Local constants
+const meshCellsCellAttributeSchemas = viewer_schemas.opengeodeweb_viewer.mesh.cells.attribute.cell;
+
+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 isMeshCellsCellAttributeValid({
+  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 useMeshCellsCellAttributeStyle(): {
+  meshCellsCellAttributeName: (id: string) => string | undefined;
+  meshCellsCellAttributeItem: (id: string) => number;
+  meshCellsCellAttributeRange: (id: string) => [number | undefined, number | undefined];
+  meshCellsCellAttributeColorMap: (id: string) => string | undefined;
+  meshCellsCellAttributeStoredConfig: (
+    id: string,
+    name: string | undefined,
+    item: number | undefined,
+  ) => AttributeStoredConfig;
+  setMeshCellsCellAttribute: (id: string, input: AttributeInput) => Promise<unknown>;
+  setMeshCellsCellAttributeName: (id: string, name: string) => Promise<unknown>;
+  setMeshCellsCellAttributeItem: (id: string, item: number) => Promise<unknown>;
+  setMeshCellsCellAttributeRange: (
+    id: string,
+    minimum: number,
+    maximum: number,
+  ) => Promise<unknown>;
+  setMeshCellsCellAttributeColorMap: (id: string, colorMap: string | undefined) => Promise<unknown>;
+  meshCellsCellAttributeNoDataColor: (id: string) => unknown;
+  setMeshCellsCellAttributeNoDataColor: (id: string, no_data_color: unknown) => Promise<unknown>;
+} {
+  const viewerStore = useViewerStore();
+  const meshCellsCommonStyle = useMeshCellsCommonStyle();
+  function meshCellsCellAttribute(id: string): AttributeState {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring.cell shape is defined by the data style schema.
+    return meshCellsCommonStyle.meshCellsColoring(id).cell as AttributeState;
+  }
+  function meshCellsCellAttributeStoredConfig(
+    id: string,
+    name: string | undefined,
+    item: number | undefined,
+  ): AttributeStoredConfig {
+    const { storedConfigs } = meshCellsCellAttribute(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 mutateMeshCellsCellStyle(
+    id: string,
+    values: Record<string, unknown>,
+  ): Promise<string> {
+    const result = await meshCellsCommonStyle.mutateMeshCellsStyle(id, {
+      coloring: {
+        cell: values,
+      },
+    });
+    return result;
+  }
+  async function setMeshCellsCellAttributeStoredConfig(
+    id: string,
+    name: string | undefined,
+    item: number | undefined,
+    config: Partial<AttributeStoredConfig>,
+  ): Promise<string> {
+    const result = await mutateMeshCellsCellStyle(id, {
+      storedConfigs: {
+        [name ?? ""]: {
+          lastItem: item,
+          [item ?? 0]: config,
+        },
+      },
+    });
+    return result;
+  }
+  function meshCellsCellAttributeName(id: string): string | undefined {
+    return meshCellsCellAttribute(id).name;
+  }
+  function meshCellsCellAttributeLastItem(id: string, name: string | undefined): number {
+    const { storedConfigs } = meshCellsCellAttribute(id);
+    const nameConfig = name === undefined ? undefined : storedConfigs?.[name];
+    if (nameConfig !== undefined) {
+      return nameConfig.lastItem;
+    }
+    return 0;
+  }
+  function meshCellsCellAttributeItem(id: string): number {
+    const { item, name } = meshCellsCellAttribute(id);
+    return item ?? meshCellsCellAttributeLastItem(id, name);
+  }
+  async function setMeshCellsCellAttribute(
+    id: string,
+    {
+      name,
+      item,
+      minimum,
+      maximum,
+      colorMap,
+      no_data_color = DEFAULT_NO_DATA_COLOR,
+    }: AttributeInput,
+  ): Promise<unknown> {
+    await mutateMeshCellsCellStyle(id, {
+      name,
+      item,
+    });
+    await setMeshCellsCellAttributeStoredConfig(id, name, item, {
+      minimum,
+      maximum,
+      colorMap,
+      no_data_color,
+    });
+    const points = getRGBPointsFromPreset(colorMap ?? "");
+    const schema = meshCellsCellAttributeSchemas.attribute;
+    const params = {
+      id,
+      name,
+      item,
+      points,
+      minimum,
+      maximum,
+      no_data_color,
+    };
+    return viewerStore.request({
+      schema,
+      params,
+    });
+  }
+  async function applyCellAttribute(id: string): Promise<unknown> {
+    const name = meshCellsCellAttributeName(id);
+    const item = meshCellsCellAttributeItem(id);
+    const storedConfig = meshCellsCellAttributeStoredConfig(id, name, item);
+    const attribute = {
+      name,
+      item,
+      minimum: storedConfig.minimum,
+      maximum: storedConfig.maximum,
+      colorMap: storedConfig.colorMap,
+      no_data_color: storedConfig.no_data_color,
+    };
+    if (isMeshCellsCellAttributeValid(attribute)) {
+      const result = await setMeshCellsCellAttribute(id, attribute);
+      return result;
+    }
+    return undefined;
+  }
+  async function setMeshCellsCellAttributeName(id: string, name: string): Promise<unknown> {
+    const item = meshCellsCellAttributeLastItem(id, name);
+    await mutateMeshCellsCellStyle(id, {
+      name,
+      item,
+    });
+    return applyCellAttribute(id);
+  }
+  async function setMeshCellsCellAttributeItem(id: string, item: number): Promise<unknown> {
+    await mutateMeshCellsCellStyle(id, {
+      item,
+    });
+    return applyCellAttribute(id);
+  }
+  function meshCellsCellAttributeRange(id: string): [number | undefined, number | undefined] {
+    const name = meshCellsCellAttributeName(id);
+    const item = meshCellsCellAttributeItem(id);
+    const storedConfig = meshCellsCellAttributeStoredConfig(id, name, item);
+    return [storedConfig.minimum, storedConfig.maximum];
+  }
+  async function setMeshCellsCellAttributeRange(
+    id: string,
+    minimum: number,
+    maximum: number,
+  ): Promise<unknown> {
+    const name = meshCellsCellAttributeName(id);
+    const item = meshCellsCellAttributeItem(id);
+    await setMeshCellsCellAttributeStoredConfig(id, name, item, {
+      minimum,
+      maximum,
+    });
+    return applyCellAttribute(id);
+  }
+  function meshCellsCellAttributeColorMap(id: string): string | undefined {
+    const name = meshCellsCellAttributeName(id);
+    const item = meshCellsCellAttributeItem(id);
+    const storedConfig = meshCellsCellAttributeStoredConfig(id, name, item);
+    return storedConfig.colorMap;
+  }
+  async function setMeshCellsCellAttributeColorMap(
+    id: string,
+    colorMap: string | undefined,
+  ): Promise<unknown> {
+    const name = meshCellsCellAttributeName(id);
+    const item = meshCellsCellAttributeItem(id);
+    await setMeshCellsCellAttributeStoredConfig(id, name, item, {
+      colorMap,
+    });
+    return applyCellAttribute(id);
+  }
+  function meshCellsCellAttributeNoDataColor(id: string): unknown {
+    const name = meshCellsCellAttributeName(id);
+    const item = meshCellsCellAttributeItem(id);
+    const storedConfig = meshCellsCellAttributeStoredConfig(id, name, item);
+    return storedConfig.no_data_color;
+  }
+  async function setMeshCellsCellAttributeNoDataColor(
+    id: string,
+    no_data_color: unknown,
+  ): Promise<unknown> {
+    const name = meshCellsCellAttributeName(id);
+    const item = meshCellsCellAttributeItem(id);
+    const storedConfig = meshCellsCellAttributeStoredConfig(id, name, item);
+    await setMeshCellsCellAttributeStoredConfig(id, name, item, {
+      ...storedConfig,
+      no_data_color,
+    });
+    return applyCellAttribute(id);
+  }
+  return {
+    meshCellsCellAttributeName,
+    meshCellsCellAttributeItem,
+    meshCellsCellAttributeRange,
+    meshCellsCellAttributeColorMap,
+    meshCellsCellAttributeStoredConfig,
+    setMeshCellsCellAttribute,
+    setMeshCellsCellAttributeName,
+    setMeshCellsCellAttributeItem,
+    setMeshCellsCellAttributeRange,
+    setMeshCellsCellAttributeColorMap,
+    meshCellsCellAttributeNoDataColor,
+    setMeshCellsCellAttributeNoDataColor,
+  };
+}
+export { isMeshCellsCellAttributeValid, useMeshCellsCellAttributeStyle };

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

@@ -8,27 +8,33 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const schema = viewer_schemas.opengeodeweb_viewer.mesh.cells.color;
 
-export function useMeshCellsColorStyle() {
+export function useMeshCellsColorStyle(): {
+  meshCellsColor: (id: string) => unknown;
+  setMeshCellsColor: (id: string, color: unknown) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const meshCellsCommonStyle = useMeshCellsCommonStyle();
 
-  function meshCellsColor(id) {
+  function meshCellsColor(id: string): unknown {
     return meshCellsCommonStyle.meshCellsColoring(id).constant;
   }
-  function setMeshCellsColor(id, color) {
+  async function setMeshCellsColor(id: string, color: unknown): Promise<unknown> {
     const params = { id, color };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
-        response_function: () =>
-          meshCellsCommonStyle.mutateMeshCellsColoring(id, {
+        response_function: async () => {
+          const mutateResult = await meshCellsCommonStyle.mutateMeshCellsColoring(id, {
             constant: color,
-          }),
+          });
+          return mutateResult;
+        },
       },
     );
+    return result;
   }
 
   return {

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

@@ -0,0 +1,50 @@
+import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
+import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
+
+export function useMeshCellsCommonStyle(): {
+  meshCellsStyle: (id: string) => StyleValues;
+  meshCellsColoring: (id: string) => StyleValues;
+  mutateMeshCellsStyle: (id: string, values: StyleValues) => Promise<string>;
+  mutateMeshCellsColoring: (id: string, values: StyleValues) => Promise<string>;
+  mutateMeshCellsCellStyle: (id: string, values: StyleValues) => Promise<string>;
+} {
+  const dataStyleState = useDataStyleState();
+
+  async function mutateMeshCellsStyle(id: string, values: StyleValues): Promise<string> {
+    const result = await dataStyleState.mutateStyle(id, {
+      cells: values,
+    });
+    return result;
+  }
+
+  function meshCellsStyle(id: string): StyleValues {
+    return dataStyleState.getStyle(id).cells ?? {};
+  }
+
+  function meshCellsColoring(id: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring shape is defined by the data style schema.
+    return meshCellsStyle(id).coloring as StyleValues;
+  }
+
+  async function mutateMeshCellsColoring(id: string, values: StyleValues): Promise<string> {
+    const result = await mutateMeshCellsStyle(id, {
+      coloring: values,
+    });
+    return result;
+  }
+
+  async function mutateMeshCellsCellStyle(id: string, values: StyleValues): Promise<string> {
+    const result = await mutateMeshCellsColoring(id, {
+      cell: values,
+    });
+    return result;
+  }
+
+  return {
+    meshCellsStyle,
+    meshCellsColoring,
+    mutateMeshCellsStyle,
+    mutateMeshCellsColoring,
+    mutateMeshCellsCellStyle,
+  };
+}

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

@@ -0,0 +1,161 @@
+// Third party imports
+
+// Local imports
+import { isMeshCellsCellAttributeValid, useMeshCellsCellAttributeStyle } from "./cell";
+import { isMeshCellsVertexAttributeValid, useMeshCellsVertexAttributeStyle } from "./vertex";
+import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
+import { useMeshCellsColorStyle } from "./color";
+import { useMeshCellsCommonStyle } from "./common";
+import { useMeshCellsTexturesStyle } from "./textures";
+import { useMeshCellsVisibilityStyle } from "./visibility";
+
+// Local constants
+
+interface MeshCellsActiveColoringDeps {
+  readonly commonStyle: ReturnType<typeof useMeshCellsCommonStyle>;
+  readonly colorStyle: ReturnType<typeof useMeshCellsColorStyle>;
+  readonly texturesStyle: ReturnType<typeof useMeshCellsTexturesStyle>;
+  readonly vertexAttributeStyle: ReturnType<typeof useMeshCellsVertexAttributeStyle>;
+  readonly cellAttributeStyle: ReturnType<typeof useMeshCellsCellAttributeStyle>;
+}
+
+function handleMeshCellsVertexColoring(
+  id: string,
+  vertexAttributeStyle: ReturnType<typeof useMeshCellsVertexAttributeStyle>,
+): Promise<unknown> | undefined {
+  const name = vertexAttributeStyle.meshCellsVertexAttributeName(id);
+  const item = vertexAttributeStyle.meshCellsVertexAttributeItem(id);
+  const [minimum, maximum] = vertexAttributeStyle.meshCellsVertexAttributeRange(id);
+  const colorMap = vertexAttributeStyle.meshCellsVertexAttributeColorMap(id);
+  const vertex_attribute = { name, item, minimum, maximum, colorMap };
+  if (!isMeshCellsVertexAttributeValid(vertex_attribute)) {
+    return undefined;
+  }
+  return vertexAttributeStyle.setMeshCellsVertexAttribute(id, vertex_attribute);
+}
+
+function handleMeshCellsCellColoring(
+  id: string,
+  cellAttributeStyle: ReturnType<typeof useMeshCellsCellAttributeStyle>,
+): Promise<unknown> | undefined {
+  const name = cellAttributeStyle.meshCellsCellAttributeName(id);
+  const item = cellAttributeStyle.meshCellsCellAttributeItem(id);
+  const [minimum, maximum] = cellAttributeStyle.meshCellsCellAttributeRange(id);
+  const colorMap = cellAttributeStyle.meshCellsCellAttributeColorMap(id);
+  const cell_attribute = { name, item, minimum, maximum, colorMap };
+  if (!isMeshCellsCellAttributeValid(cell_attribute)) {
+    return undefined;
+  }
+  return cellAttributeStyle.setMeshCellsCellAttribute(id, cell_attribute);
+}
+
+async function setMeshCellsActiveColoring(
+  id: string,
+  type: string | undefined,
+  deps: MeshCellsActiveColoringDeps,
+): Promise<unknown> {
+  await deps.commonStyle.mutateMeshCellsStyle(id, {
+    coloring: { active: type },
+  });
+  if (type === "constant") {
+    const result = await deps.colorStyle.setMeshCellsColor(id, deps.colorStyle.meshCellsColor(id));
+    return result;
+  }
+  if (type === "textures") {
+    const result = await deps.texturesStyle.setMeshCellsTextures(
+      id,
+      deps.texturesStyle.meshCellsTextures(id),
+    );
+    return result;
+  }
+  if (type === "vertex") {
+    const result = await handleMeshCellsVertexColoring(id, deps.vertexAttributeStyle);
+    return result;
+  }
+  if (type === "cell") {
+    const result = await handleMeshCellsCellColoring(id, deps.cellAttributeStyle);
+    return result;
+  }
+  throw new Error(`Unknown mesh cells coloring type: ${type}`);
+}
+
+async function applyMeshCellsStyle(
+  id: string,
+  visibilityStyle: ReturnType<typeof useMeshCellsVisibilityStyle>,
+  activeColoringType: string | undefined,
+  deps: MeshCellsActiveColoringDeps,
+): Promise<unknown[]> {
+  const result = await Promise.all([
+    visibilityStyle.setMeshCellsVisibility(id, visibilityStyle.meshCellsVisibility(id)),
+    setMeshCellsActiveColoring(id, activeColoringType, deps),
+  ]);
+  return result;
+}
+
+type UseMeshCellsStyleReturn = ReturnType<typeof useMeshCellsCommonStyle> & {
+  meshCellsColoring: (id: string) => StyleValues;
+  meshCellsActiveColoring: (id: string) => string | undefined;
+  setMeshCellsActiveColoring: (id: string, type: string | undefined) => Promise<unknown>;
+  applyMeshCellsStyle: (id: string) => Promise<unknown[]>;
+} & ReturnType<typeof useMeshCellsVisibilityStyle> &
+  ReturnType<typeof useMeshCellsColorStyle> &
+  ReturnType<typeof useMeshCellsTexturesStyle> &
+  ReturnType<typeof useMeshCellsVertexAttributeStyle> &
+  ReturnType<typeof useMeshCellsCellAttributeStyle>;
+
+export function useMeshCellsStyle(): UseMeshCellsStyleReturn {
+  const meshCellsCommonStyle = useMeshCellsCommonStyle();
+  const meshCellsVisibility = useMeshCellsVisibilityStyle();
+  const meshCellsColorStyle = useMeshCellsColorStyle();
+  const meshCellsTexturesStore = useMeshCellsTexturesStyle();
+  const meshCellsVertexAttributeStyle = useMeshCellsVertexAttributeStyle();
+  const meshCellsCellAttributeStyle = useMeshCellsCellAttributeStyle();
+
+  const activeColoringDeps: MeshCellsActiveColoringDeps = {
+    commonStyle: meshCellsCommonStyle,
+    colorStyle: meshCellsColorStyle,
+    texturesStyle: meshCellsTexturesStore,
+    vertexAttributeStyle: meshCellsVertexAttributeStyle,
+    cellAttributeStyle: meshCellsCellAttributeStyle,
+  };
+
+  function meshCellsColoring(id: string): StyleValues {
+    return meshCellsCommonStyle.meshCellsColoring(id);
+  }
+
+  function meshCellsActiveColoring(id: string): string | undefined {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring.active is defined as string in the data style schema.
+    return meshCellsColoring(id).active as string | undefined;
+  }
+
+  async function boundSetMeshCellsActiveColoring(
+    id: string,
+    type: string | undefined,
+  ): Promise<unknown> {
+    const result = await setMeshCellsActiveColoring(id, type, activeColoringDeps);
+    return result;
+  }
+
+  async function boundApplyMeshCellsStyle(id: string): Promise<unknown[]> {
+    const result = await applyMeshCellsStyle(
+      id,
+      meshCellsVisibility,
+      meshCellsActiveColoring(id),
+      activeColoringDeps,
+    );
+    return result;
+  }
+
+  return {
+    ...meshCellsCommonStyle,
+    meshCellsColoring,
+    meshCellsActiveColoring,
+    setMeshCellsActiveColoring: boundSetMeshCellsActiveColoring,
+    applyMeshCellsStyle: boundApplyMeshCellsStyle,
+    ...meshCellsVisibility,
+    ...meshCellsColorStyle,
+    ...meshCellsTexturesStore,
+    ...meshCellsVertexAttributeStyle,
+    ...meshCellsCellAttributeStyle,
+  };
+}

package/internal/stores/data_style/mesh/cells/{textures.js → textures.ts}

@@ -6,29 +6,35 @@ import { useMeshCellsCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const schema = viewer_schemas.opengeodeweb_viewer.mesh.cells.apply_textures;
+const schema = viewer_schemas.opengeodeweb_viewer.mesh.apply_textures;
 
-export function useMeshCellsTexturesStyle() {
+export function useMeshCellsTexturesStyle(): {
+  meshCellsTextures: (id: string) => unknown;
+  setMeshCellsTextures: (id: string, textures: unknown) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const meshCellsCommonStyle = useMeshCellsCommonStyle();
 
-  function meshCellsTextures(id) {
+  function meshCellsTextures(id: string): unknown {
     return meshCellsCommonStyle.meshCellsColoring(id).textures;
   }
-  function setMeshCellsTextures(id, textures) {
+  async function setMeshCellsTextures(id: string, textures: unknown): Promise<unknown> {
     const params = { id, textures };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
-        response_function: () =>
-          meshCellsCommonStyle.mutateMeshCellsStyle(id, {
+        response_function: async () => {
+          const mutateResult = await meshCellsCommonStyle.mutateMeshCellsStyle(id, {
             coloring: { textures },
-          }),
+          });
+          return mutateResult;
+        },
       },
     );
+    return result;
   }
 
   return {