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

package/internal/stores/data_style/model/blocks/visibility.js

@@ -1,20 +0,0 @@
-import { useModelBlocksCommonStyle } from "./common";
-import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
-
-const schema = viewer_schemas.opengeodeweb_viewer.model.blocks.visibility;
-
-export function useModelBlocksVisibility() {
-  const modelCommonStyle = useModelCommonStyle();
-  const modelBlocksCommonStyle = useModelBlocksCommonStyle();
-
-  function modelBlockVisibility(id, block_id) {
-    return modelBlocksCommonStyle.modelBlockStyle(id, block_id).visibility;
-  }
-
-  function setModelBlocksVisibility(modelId, blocks_ids, visibility) {
-    return modelCommonStyle.setModelTypeVisibility(modelId, blocks_ids, visibility, schema);
-  }
-
-  return { setModelBlocksVisibility, modelBlockVisibility };
-}

package/internal/stores/data_style/model/color.js

@@ -1,218 +0,0 @@
-import { dispatchToComponentTypes } from "./visibility";
-import { useDataStore } from "@ogw_front/stores/data";
-import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
-import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
-
-function useModelColorStyle(componentStyleFunctions) {
-  const dataStore = useDataStore();
-  const dataStyleState = useDataStyleState();
-  const modelCommonStyle = useModelCommonStyle();
-  const { Surface, Line, Block, Corner } = componentStyleFunctions;
-  const ATTRIBUTE_FUNCTIONS = {
-    Surface: {
-      vertex: {
-        getName: Surface.modelSurfacesVertexAttributeName,
-        setName: Surface.setModelSurfacesVertexAttributeName,
-        getRange: Surface.modelSurfacesVertexAttributeRange,
-        setRange: Surface.setModelSurfacesVertexAttributeRange,
-        getColorMap: Surface.modelSurfacesVertexAttributeColorMap,
-        setColorMap: Surface.setModelSurfacesVertexAttributeColorMap,
-      },
-      polygon: {
-        getName: Surface.modelSurfacesPolygonAttributeName,
-        setName: Surface.setModelSurfacesPolygonAttributeName,
-        getRange: Surface.modelSurfacesPolygonAttributeRange,
-        setRange: Surface.setModelSurfacesPolygonAttributeRange,
-        getColorMap: Surface.modelSurfacesPolygonAttributeColorMap,
-        setColorMap: Surface.setModelSurfacesPolygonAttributeColorMap,
-      },
-    },
-    Line: {
-      vertex: {
-        getName: Line.modelLinesVertexAttributeName,
-        setName: Line.setModelLinesVertexAttributeName,
-        getRange: Line.modelLinesVertexAttributeRange,
-        setRange: Line.setModelLinesVertexAttributeRange,
-        getColorMap: Line.modelLinesVertexAttributeColorMap,
-        setColorMap: Line.setModelLinesVertexAttributeColorMap,
-      },
-      edge: {
-        getName: Line.modelLinesEdgeAttributeName,
-        setName: Line.setModelLinesEdgeAttributeName,
-        getRange: Line.modelLinesEdgeAttributeRange,
-        setRange: Line.setModelLinesEdgeAttributeRange,
-        getColorMap: Line.modelLinesEdgeAttributeColorMap,
-        setColorMap: Line.setModelLinesEdgeAttributeColorMap,
-      },
-    },
-    Block: {
-      vertex: {
-        getName: Block.modelBlocksVertexAttributeName,
-        setName: Block.setModelBlocksVertexAttributeName,
-        getRange: Block.modelBlocksVertexAttributeRange,
-        setRange: Block.setModelBlocksVertexAttributeRange,
-        getColorMap: Block.modelBlocksVertexAttributeColorMap,
-        setColorMap: Block.setModelBlocksVertexAttributeColorMap,
-      },
-      polyhedron: {
-        getName: Block.modelBlocksPolyhedronAttributeName,
-        setName: Block.setModelBlocksPolyhedronAttributeName,
-        getRange: Block.modelBlocksPolyhedronAttributeRange,
-        setRange: Block.setModelBlocksPolyhedronAttributeRange,
-        getColorMap: Block.modelBlocksPolyhedronAttributeColorMap,
-        setColorMap: Block.setModelBlocksPolyhedronAttributeColorMap,
-      },
-    },
-    Corner: {
-      vertex: {
-        getName: Corner.modelCornersVertexAttributeName,
-        setName: Corner.setModelCornersVertexAttributeName,
-        getRange: Corner.modelCornersVertexAttributeRange,
-        setRange: Corner.setModelCornersVertexAttributeRange,
-        getColorMap: Corner.modelCornersVertexAttributeColorMap,
-        setColorMap: Corner.setModelCornersVertexAttributeColorMap,
-      },
-    },
-  };
-  function getModelComponentColor(modelId, componentId) {
-    return dataStyleState.getComponentStyle(modelId, componentId).coloring?.constant;
-  }
-  function modelComponentTypeColor(modelId, type) {
-    return (
-      dataStyleState.getModelComponentTypeStyle(modelId, type).coloring?.constant ||
-      dataStyleState.getStyle(modelId)[`${type.toLowerCase()}s`].coloring.constant
-    );
-  }
-  function getModelComponentEffectiveColor(modelId, componentId, type) {
-    const individualColor = getModelComponentColor(modelId, componentId);
-    if (individualColor !== undefined) {
-      return individualColor;
-    }
-    return modelComponentTypeColor(modelId, type);
-  }
-  function getModelComponentActiveColoring(modelId, componentId) {
-    return dataStyleState.getComponentStyle(modelId, componentId).coloring?.active;
-  }
-  function getModelComponentTypeActiveColoring(modelId, type) {
-    return (
-      dataStyleState.getModelComponentTypeStyle(modelId, type).coloring?.active ||
-      dataStyleState.getStyle(modelId)[`${type.toLowerCase()}s`].coloring.active
-    );
-  }
-  async function setModelComponentsColor(
-    modelId,
-    componentIds,
-    color,
-    activeColoring = "constant",
-  ) {
-    await modelCommonStyle.mutateComponentStyles(modelId, componentIds, {
-      coloring: {
-        constant: color,
-        active: activeColoring,
-      },
-    });
-    return await dispatchToComponentTypes(
-      modelId,
-      componentIds,
-      "Color",
-      {
-        componentStyleFunctions,
-      },
-      color,
-      activeColoring,
-    );
-  }
-  async function setModelComponentTypeColor(modelId, type, color) {
-    await modelCommonStyle.mutateModelComponentTypeStyle(modelId, type, {
-      coloring: {
-        constant: color,
-        active: "constant",
-      },
-    });
-    const idsForType = await dataStore.getMeshComponentGeodeIds(modelId, type);
-    if (idsForType.length === 0) {
-      return;
-    }
-    await setModelComponentsColor(modelId, idsForType, color);
-  }
-  async function setModelComponentTypeActiveColoring(modelId, type, activeColoring) {
-    await modelCommonStyle.mutateModelComponentTypeStyle(modelId, type, {
-      coloring: {
-        active: activeColoring,
-      },
-    });
-    const idsForType = await dataStore.getMeshComponentGeodeIds(modelId, type);
-    if (idsForType.length === 0) {
-      return;
-    }
-    if (activeColoring === "random" || activeColoring === "constant") {
-      await setModelComponentsColor(modelId, idsForType, undefined, activeColoring);
-      return;
-    }
-    await modelCommonStyle.mutateComponentStyles(modelId, idsForType, {
-      coloring: {
-        active: activeColoring,
-      },
-    });
-    const { getName, setName, getRange, setRange, getColorMap, setColorMap } =
-      ATTRIBUTE_FUNCTIONS[type][activeColoring];
-    const name = getName(modelId, idsForType[0]);
-    if (name) {
-      await setName(modelId, idsForType, name);
-      const [minimum, maximum] = getRange(modelId, idsForType[0]);
-      if (minimum !== undefined && maximum !== undefined) {
-        await setRange(modelId, idsForType, minimum, maximum);
-      }
-      const colorMap = getColorMap(modelId, idsForType[0]);
-      if (colorMap) {
-        await setColorMap(modelId, idsForType, colorMap);
-      }
-    }
-  }
-  async function setModelComponentActiveColoring(modelId, componentId, activeColoring) {
-    await modelCommonStyle.mutateComponentStyle(modelId, componentId, {
-      coloring: {
-        active: activeColoring,
-      },
-    });
-    if (activeColoring === "random" || activeColoring === "constant") {
-      await setModelComponentsColor(modelId, [componentId], undefined, activeColoring);
-      return;
-    }
-    const type = await dataStore.meshComponentType(modelId, componentId);
-    const { getName, setName, getRange, setRange, getColorMap, setColorMap } =
-      ATTRIBUTE_FUNCTIONS[type][activeColoring];
-    const name = getName(modelId, componentId);
-    if (name) {
-      await setName(modelId, [componentId], name);
-      const [minimum, maximum] = getRange(modelId, componentId);
-      if (minimum !== undefined && maximum !== undefined) {
-        await setRange(modelId, [componentId], minimum, maximum);
-      }
-      const colorMap = getColorMap(modelId, componentId);
-      if (colorMap) {
-        await setColorMap(modelId, [componentId], colorMap);
-      }
-    }
-  }
-  function getModelColor(modelId) {
-    return dataStyleState.getStyle(modelId).coloring.constant;
-  }
-  function getModelActiveColoring(modelId) {
-    return dataStyleState.getStyle(modelId).coloring.active;
-  }
-  return {
-    getModelColor,
-    getModelActiveColoring,
-    getModelComponentColor,
-    getModelComponentEffectiveColor,
-    getModelComponentActiveColoring,
-    modelComponentTypeColor,
-    getModelComponentTypeActiveColoring,
-    setModelComponentTypeColor,
-    setModelComponentTypeActiveColoring,
-    setModelComponentActiveColoring,
-    setModelComponentsColor,
-  };
-}
-export { useModelColorStyle };

package/internal/stores/data_style/model/common.js

@@ -1,141 +0,0 @@
-import { database } from "@ogw_internal/database/database";
-import merge from "lodash/merge";
-import { useDataStore } from "@ogw_front/stores/data";
-import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
-import { useViewerStore } from "@ogw_front/stores/viewer";
-
-// oxlint-disable-next-line max-lines-per-function
-export function useModelCommonStyle() {
-  const dataStore = useDataStore();
-  const viewerStore = useViewerStore();
-  const dataStyleState = useDataStyleState();
-  const model_component_datastyle_db = database.model_component_datastyle;
-  const model_component_type_datastyle_db = database.model_component_type_datastyle;
-
-  async function mutateComponentStyle(id_model, id_component, values) {
-    dataStyleState.updateComponentStyleCache(id_model, id_component, values);
-    const key = [id_model, id_component];
-    const entry = (await model_component_datastyle_db.get(key)) || { id_model, id_component };
-    merge(entry, values);
-    return model_component_datastyle_db.put(structuredClone(toRaw(entry)));
-  }
-
-  async function mutateModelComponentTypeStyle(id_model, type, values) {
-    dataStyleState.updateModelComponentTypeStyleCache(id_model, type, values);
-    await database.transaction("rw", model_component_type_datastyle_db, async () => {
-      const key = [id_model, type];
-      const entry = (await model_component_type_datastyle_db.get(key)) || { id_model, type };
-      merge(entry, values);
-      return model_component_type_datastyle_db.put(structuredClone(toRaw(entry)));
-    });
-  }
-
-  async function mutateComponentStyles(id_model, id_components, values) {
-    dataStyleState.bulkUpdateComponentStylesCache(id_model, id_components, values);
-    await database.transaction("rw", model_component_datastyle_db, async () => {
-      const keys = id_components.map((id_component) => [id_model, id_component]);
-      const existing = await model_component_datastyle_db.bulkGet(keys);
-      const updates = id_components.map((id_component, index) => {
-        const style = existing[index] || { id_model, id_component };
-        merge(style, values);
-        return toRaw(style);
-      });
-
-      return model_component_datastyle_db.bulkPut(structuredClone(updates));
-    });
-  }
-
-  async function bulkMutateComponentStylesPerComponent(id_model, component_updates) {
-    dataStyleState.bulkUpdateComponentStyleCache(id_model, component_updates);
-    await database.transaction("rw", model_component_datastyle_db, async () => {
-      const keys = component_updates.map((update) => [id_model, update.id_component]);
-      const existing = await model_component_datastyle_db.bulkGet(keys);
-      const updates = component_updates.map(({ id_component, values }, index) => {
-        const style = existing[index] || { id_model, id_component };
-        merge(style, values);
-        return toRaw(style);
-      });
-      return model_component_datastyle_db.bulkPut(structuredClone(updates));
-    });
-  }
-
-  async function setModelTypeColor(id, component_ids, color, schema, activeColoring = "constant") {
-    if (!component_ids?.length) {
-      return;
-    }
-
-    const viewer_ids = await dataStore.getMeshComponentsViewerIds(id, component_ids);
-    if (!viewer_ids?.length) {
-      return;
-    }
-
-    const params = { id, block_ids: viewer_ids, color_mode: activeColoring };
-    if (activeColoring === "constant") {
-      await mutateComponentStyles(id, component_ids, {
-        coloring: {
-          constant: color,
-        },
-      });
-      params.color = color;
-    }
-
-    return viewerStore.request(
-      { schema, params },
-      {
-        response_function: async (colors) => {
-          if (activeColoring === "constant") {
-            await mutateComponentStyles(id, component_ids, {
-              coloring: {
-                constant: color,
-              },
-            });
-            return;
-          }
-
-          if (!colors?.length) {
-            return;
-          }
-
-          await bulkMutateComponentStylesPerComponent(
-            id,
-            colors.map(({ geode_id, color: color_value }) => ({
-              id_component: geode_id,
-              values: {
-                coloring: {
-                  constant: color_value,
-                },
-              },
-            })),
-          );
-        },
-      },
-    );
-  }
-
-  async function setModelTypeVisibility(id, component_ids, visibility, schema) {
-    if (!component_ids?.length) {
-      return;
-    }
-
-    const viewer_ids = await dataStore.getMeshComponentsViewerIds(id, component_ids);
-    if (!viewer_ids?.length) {
-      return;
-    }
-    const params = { id, block_ids: viewer_ids, visibility };
-    return viewerStore.request(
-      { schema, params },
-      {
-        response_function: () => mutateComponentStyles(id, component_ids, { visibility }),
-      },
-    );
-  }
-
-  return {
-    mutateComponentStyle,
-    mutateModelComponentTypeStyle,
-    mutateComponentStyles,
-    bulkMutateComponentStylesPerComponent,
-    setModelTypeColor,
-    setModelTypeVisibility,
-  };
-}

package/internal/stores/data_style/model/corners/common.js

@@ -1,51 +0,0 @@
-import merge from "lodash/merge";
-import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
-import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
-
-export function useModelCornersCommonStyle() {
-  const dataStyleState = useDataStyleState();
-  const modelCommonStyle = useModelCommonStyle();
-
-  function modelCornersStyle(id) {
-    return dataStyleState.getStyle(id).corners;
-  }
-
-  function modelComponentTypeCornersStyle(id) {
-    const defaultStyle = modelCornersStyle(id);
-    const typeStyle = dataStyleState.getModelComponentTypeStyle(id, "Corner");
-    return merge({}, defaultStyle, typeStyle);
-  }
-
-  function modelCornerStyle(id, corner_id) {
-    if (corner_id === undefined) {
-      return modelComponentTypeCornersStyle(id);
-    }
-    const typeStyle = modelComponentTypeCornersStyle(id);
-    const individualStyle = dataStyleState.getComponentStyle(id, corner_id);
-    return merge({}, typeStyle, individualStyle);
-  }
-
-  function modelCornerColoring(id, corner_id) {
-    return modelCornerStyle(id, corner_id).coloring;
-  }
-
-  function mutateModelCornersColoring(id, corners_ids, values) {
-    return modelCommonStyle.mutateComponentStyles(id, corners_ids, {
-      coloring: values,
-    });
-  }
-
-  function mutateModelCornersTypeColoring(id, values) {
-    return modelCommonStyle.mutateModelComponentTypeStyle(id, "Corner", {
-      coloring: values,
-    });
-  }
-
-  return {
-    modelCornersStyle,
-    modelCornerStyle,
-    modelCornerColoring,
-    mutateModelCornersColoring,
-    mutateModelCornersTypeColoring,
-  };
-}

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

@@ -1,204 +0,0 @@
-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 { useModelCornersCommonStyle } from "./common";
-import { useViewerStore } from "@ogw_front/stores/viewer";
-
-// Local constants
-const attributeSchema = viewer_schemas.opengeodeweb_viewer.model.corners.attribute.vertex.attribute;
-function isModelCornersVertexAttributeValid({ name, item, minimum, maximum, colorMap }) {
-  return (
-    name !== undefined &&
-    item !== undefined &&
-    minimum !== undefined &&
-    maximum !== undefined &&
-    colorMap !== undefined
-  );
-}
-
-// oxlint-disable-next-line max-lines-per-function
-function useModelCornersVertexAttribute() {
-  const dataStore = useDataStore();
-  const modelCornersCommonStyle = useModelCornersCommonStyle();
-  const viewerStore = useViewerStore();
-  function modelCornersVertexAttribute(modelId, cornerId) {
-    return modelCornersCommonStyle.modelCornerColoring(modelId, cornerId).vertex;
-  }
-  function modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item) {
-    const { storedConfigs } = modelCornersVertexAttribute(modelId, cornerId);
-    if (storedConfigs && name in storedConfigs && item in storedConfigs[name]) {
-      return storedConfigs[name][item];
-    }
-    return {
-      minimum: undefined,
-      maximum: undefined,
-      colorMap: undefined,
-      no_data_color: DEFAULT_NO_DATA_COLOR,
-    };
-  }
-  function mutateModelCornersVertexStyle(modelId, cornerIds, values) {
-    if (cornerIds.length > 1) {
-      modelCornersCommonStyle.mutateModelCornersTypeColoring(modelId, {
-        vertex: values,
-      });
-    }
-    return modelCornersCommonStyle.mutateModelCornersColoring(modelId, cornerIds, {
-      vertex: values,
-    });
-  }
-  function setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, config) {
-    return mutateModelCornersVertexStyle(modelId, cornerIds, {
-      storedConfigs: {
-        [name]: {
-          lastItem: item,
-          [item]: config,
-        },
-      },
-    });
-  }
-  function modelCornersVertexAttributeName(modelId, cornerId) {
-    return modelCornersVertexAttribute(modelId, cornerId).name;
-  }
-  function modelCornersVertexAttributeLastItem(modelId, cornerId, name) {
-    const { storedConfigs } = modelCornersVertexAttribute(modelId, cornerId);
-    if (!(name in storedConfigs)) {
-      return 0;
-    }
-    return storedConfigs[name].lastItem;
-  }
-  function modelCornersVertexAttributeItem(modelId, cornerId) {
-    const vertexAttribute = modelCornersVertexAttribute(modelId, cornerId);
-    return (
-      vertexAttribute.item ??
-      modelCornersVertexAttributeLastItem(modelId, cornerId, vertexAttribute.name)
-    );
-  }
-  function modelCornersVertexAttributeRange(modelId, cornerId) {
-    const name = modelCornersVertexAttributeName(modelId, cornerId);
-    const item = modelCornersVertexAttributeItem(modelId, cornerId);
-    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item);
-    const { minimum, maximum } = storedConfig;
-    return [minimum, maximum];
-  }
-  function modelCornersVertexAttributeColorMap(modelId, cornerId) {
-    const name = modelCornersVertexAttributeName(modelId, cornerId);
-    const item = modelCornersVertexAttributeItem(modelId, cornerId);
-    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item);
-    return storedConfig.colorMap;
-  }
-  async function setModelCornersVertexAttribute(
-    modelId,
-    cornerIds,
-    { name, item, minimum, maximum, colorMap, no_data_color = DEFAULT_NO_DATA_COLOR },
-  ) {
-    mutateModelCornersVertexStyle(modelId, cornerIds, {
-      name,
-      item,
-    });
-    setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, {
-      minimum,
-      maximum,
-      colorMap,
-      no_data_color,
-    });
-    const points = getRGBPointsFromPreset(colorMap);
-    const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, cornerIds);
-    const params = {
-      id: modelId,
-      block_ids: corner_viewer_ids,
-      name,
-      item,
-      points,
-      minimum,
-      maximum,
-      no_data_color,
-    };
-    return viewerStore.request({
-      schema: attributeSchema,
-      params,
-    });
-  }
-  function applyVertexAttribute(modelId, cornerIds) {
-    const name = modelCornersVertexAttributeName(modelId, cornerIds[0]);
-    const item = modelCornersVertexAttributeItem(modelId, cornerIds[0]);
-    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerIds[0], name, item);
-    const attribute = {
-      name,
-      item,
-      minimum: storedConfig.minimum,
-      maximum: storedConfig.maximum,
-      colorMap: storedConfig.colorMap,
-      no_data_color: storedConfig.no_data_color,
-    };
-    if (isModelCornersVertexAttributeValid(attribute)) {
-      return setModelCornersVertexAttribute(modelId, cornerIds, attribute);
-    }
-    return Promise.resolve();
-  }
-  function setModelCornersVertexAttributeName(modelId, cornerIds, name) {
-    const item = modelCornersVertexAttributeLastItem(modelId, cornerIds[0], name);
-    mutateModelCornersVertexStyle(modelId, cornerIds, {
-      name,
-      item,
-    });
-    return applyVertexAttribute(modelId, cornerIds);
-  }
-  function setModelCornersVertexAttributeItem(modelId, cornerIds, item) {
-    mutateModelCornersVertexStyle(modelId, cornerIds, {
-      item,
-    });
-    return applyVertexAttribute(modelId, cornerIds);
-  }
-  function setModelCornersVertexAttributeRange(modelId, cornerIds, minimum, maximum) {
-    const name = modelCornersVertexAttributeName(modelId, cornerIds[0]);
-    const item = modelCornersVertexAttributeItem(modelId, cornerIds[0]);
-    setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, {
-      minimum,
-      maximum,
-    });
-    return applyVertexAttribute(modelId, cornerIds);
-  }
-  function setModelCornersVertexAttributeColorMap(modelId, cornerIds, colorMap) {
-    const name = modelCornersVertexAttributeName(modelId, cornerIds[0]);
-    const item = modelCornersVertexAttributeItem(modelId, cornerIds[0]);
-    setModelCornersVertexAttributeStoredConfig(modelId, cornerIds, name, item, {
-      colorMap,
-    });
-    return applyVertexAttribute(modelId, cornerIds);
-  }
-  function modelCornersVertexAttributeNoDataColor(modelId, cornerId) {
-    const name = modelCornersVertexAttributeName(modelId, cornerId);
-    const item = modelCornersVertexAttributeItem(modelId, cornerId);
-    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item);
-    return storedConfig.no_data_color;
-  }
-  async function setModelCornersVertexAttributeNoDataColor(modelId, cornerId, no_data_color) {
-    const name = modelCornersVertexAttributeName(modelId, cornerId);
-    const item = modelCornersVertexAttributeItem(modelId, cornerId);
-    const storedConfig = modelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item);
-    await setModelCornersVertexAttributeStoredConfig(modelId, cornerId, name, item, {
-      ...storedConfig,
-      no_data_color,
-    });
-    return applyVertexAttribute(modelId, cornerId);
-  }
-  return {
-    modelCornersVertexAttributeName,
-    modelCornersVertexAttributeItem,
-    modelCornersVertexAttributeRange,
-    modelCornersVertexAttributeColorMap,
-    modelCornersVertexAttributeStoredConfig,
-    setModelCornersVertexAttribute,
-    setModelCornersVertexAttributeName,
-    setModelCornersVertexAttributeItem,
-    setModelCornersVertexAttributeRange,
-    setModelCornersVertexAttributeColorMap,
-    modelCornersVertexAttributeNoDataColor,
-    setModelCornersVertexAttributeNoDataColor,
-  };
-}
-export { isModelCornersVertexAttributeValid, useModelCornersVertexAttribute };

package/internal/stores/data_style/model/corners/visibility.js

@@ -1,20 +0,0 @@
-import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
-import { useModelCornersCommonStyle } from "./common";
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
-
-const schema = viewer_schemas.opengeodeweb_viewer.model.corners.visibility;
-
-export function useModelCornersVisibility() {
-  const modelCommonStyle = useModelCommonStyle();
-  const modelCornersCommonStyle = useModelCornersCommonStyle();
-
-  function modelCornerVisibility(id, corner_id) {
-    return modelCornersCommonStyle.modelCornerStyle(id, corner_id).visibility;
-  }
-
-  function setModelCornersVisibility(modelId, corners_ids, visibility) {
-    return modelCommonStyle.setModelTypeVisibility(modelId, corners_ids, visibility, schema);
-  }
-
-  return { setModelCornersVisibility, modelCornerVisibility };
-}

package/internal/stores/data_style/model/edges/common.js

@@ -1,20 +0,0 @@
-import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
-
-export function useModelEdgesCommonStyle() {
-  const dataStyleState = useDataStyleState();
-
-  function mutateModelEdgesStyle(id, values) {
-    return dataStyleState.mutateStyle(id, {
-      edges: values,
-    });
-  }
-
-  function modelEdgesStyle(id) {
-    return dataStyleState.getStyle(id).edges;
-  }
-
-  return {
-    modelEdgesStyle,
-    mutateModelEdgesStyle,
-  };
-}