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

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

@@ -1,195 +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 { useMeshEdgesCommonStyle } from "./common";
-import { useViewerStore } from "@ogw_front/stores/viewer";
-
-// Local constants
-const meshEdgesEdgeAttributeSchemas = viewer_schemas.opengeodeweb_viewer.mesh.edges.attribute.edge;
-function isMeshEdgesEdgeAttributeValid({ 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 useMeshEdgesEdgeAttributeStyle() {
-  const viewerStore = useViewerStore();
-  const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
-  function meshEdgesColoring(id) {
-    return meshEdgesCommonStyle.meshEdgesStyle(id).coloring;
-  }
-  function meshEdgesEdgeAttribute(id) {
-    return meshEdgesColoring(id).edge;
-  }
-  function meshEdgesEdgeAttributeStoredConfig(id, name, item) {
-    const { storedConfigs } = meshEdgesEdgeAttribute(id);
-    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 mutateMeshEdgesEdgeStyle(id, values) {
-    return meshEdgesCommonStyle.mutateMeshEdgesStyle(id, {
-      coloring: {
-        edge: values,
-      },
-    });
-  }
-  function setMeshEdgesEdgeAttributeStoredConfig(id, name, item, config) {
-    return mutateMeshEdgesEdgeStyle(id, {
-      storedConfigs: {
-        [name]: {
-          lastItem: item,
-          [item]: config,
-        },
-      },
-    });
-  }
-  function meshEdgesEdgeAttributeName(id) {
-    return meshEdgesEdgeAttribute(id).name;
-  }
-  function meshEdgesEdgeAttributeLastItem(id, name) {
-    const { storedConfigs } = meshEdgesEdgeAttribute(id);
-    if (storedConfigs && name in storedConfigs) {
-      return storedConfigs[name].lastItem;
-    }
-    return 0;
-  }
-  function meshEdgesEdgeAttributeItem(id) {
-    const { item, name } = meshEdgesEdgeAttribute(id);
-    return item ?? meshEdgesEdgeAttributeLastItem(id, name);
-  }
-  function setMeshEdgesEdgeAttribute(
-    id,
-    { name, item, minimum, maximum, colorMap, no_data_color = DEFAULT_NO_DATA_COLOR },
-  ) {
-    mutateMeshEdgesEdgeStyle(id, {
-      name,
-      item,
-    });
-    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,
-    });
-  }
-  function applyEdgeAttribute(id) {
-    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)) {
-      return setMeshEdgesEdgeAttribute(id, attribute);
-    }
-  }
-  function setMeshEdgesEdgeAttributeName(id, name) {
-    const item = meshEdgesEdgeAttributeLastItem(id, name);
-    mutateMeshEdgesEdgeStyle(id, {
-      name,
-      item,
-    });
-    return applyEdgeAttribute(id);
-  }
-  function setMeshEdgesEdgeAttributeItem(id, item) {
-    mutateMeshEdgesEdgeStyle(id, {
-      item,
-    });
-    return applyEdgeAttribute(id);
-  }
-  function meshEdgesEdgeAttributeRange(id) {
-    const name = meshEdgesEdgeAttributeName(id);
-    const item = meshEdgesEdgeAttributeItem(id);
-    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name, item);
-    return [storedConfig.minimum, storedConfig.maximum];
-  }
-  function setMeshEdgesEdgeAttributeRange(id, minimum, maximum) {
-    const name = meshEdgesEdgeAttributeName(id);
-    const item = meshEdgesEdgeAttributeItem(id);
-    setMeshEdgesEdgeAttributeStoredConfig(id, name, item, {
-      minimum,
-      maximum,
-    });
-    return applyEdgeAttribute(id);
-  }
-  function meshEdgesEdgeAttributeColorMap(id) {
-    const name = meshEdgesEdgeAttributeName(id);
-    const item = meshEdgesEdgeAttributeItem(id);
-    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name, item);
-    return storedConfig.colorMap;
-  }
-  function setMeshEdgesEdgeAttributeColorMap(id, colorMap) {
-    const name = meshEdgesEdgeAttributeName(id);
-    const item = meshEdgesEdgeAttributeItem(id);
-    setMeshEdgesEdgeAttributeStoredConfig(id, name, item, {
-      colorMap,
-    });
-    return applyEdgeAttribute(id);
-  }
-  function meshEdgesEdgeAttributeNoDataColor(id) {
-    const name = meshEdgesEdgeAttributeName(id);
-    const item = meshEdgesEdgeAttributeItem(id);
-    const storedConfig = meshEdgesEdgeAttributeStoredConfig(id, name, item);
-    return storedConfig.no_data_color;
-  }
-  async function setMeshEdgesEdgeAttributeNoDataColor(id, no_data_color) {
-    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 };

package/internal/stores/data_style/mesh/edges/index.js

@@ -1,81 +0,0 @@
-// Third party imports
-
-// Local imports
-import { isMeshEdgesEdgeAttributeValid, useMeshEdgesEdgeAttributeStyle } from "./edge";
-import { isMeshEdgesVertexAttributeValid, useMeshEdgesVertexAttributeStyle } from "./vertex";
-import { useMeshEdgesColorStyle } from "./color";
-import { useMeshEdgesCommonStyle } from "./common";
-import { useMeshEdgesVisibilityStyle } from "./visibility";
-import { useMeshEdgesWidthStyle } from "./width";
-
-// Local constants
-
-export function useMeshEdgesStyle() {
-  const meshEdgesVisibility = useMeshEdgesVisibilityStyle();
-  const meshEdgesColorStyle = useMeshEdgesColorStyle();
-  const meshEdgesWidthStyle = useMeshEdgesWidthStyle();
-  const meshEdgesVertexAttributeStyle = useMeshEdgesVertexAttributeStyle();
-  const meshEdgesEdgeAttributeStyle = useMeshEdgesEdgeAttributeStyle();
-  const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
-
-  function meshEdgesColoring(id) {
-    return meshEdgesCommonStyle.meshEdgesColoring(id);
-  }
-
-  function meshEdgesActiveColoring(id) {
-    return meshEdgesColoring(id).active;
-  }
-
-  async function setMeshEdgesActiveColoring(id, type) {
-    await meshEdgesCommonStyle.mutateMeshEdgesStyle(id, {
-      coloring: { active: type },
-    });
-    if (type === "constant") {
-      return meshEdgesColorStyle.setMeshEdgesColor(id, meshEdgesColorStyle.meshEdgesColor(id));
-    }
-    if (type === "vertex") {
-      const name = meshEdgesVertexAttributeStyle.meshEdgesVertexAttributeName(id);
-      const item = meshEdgesVertexAttributeStyle.meshEdgesVertexAttributeItem(id);
-      const [minimum, maximum] = meshEdgesVertexAttributeStyle.meshEdgesVertexAttributeRange(id);
-      const colorMap = meshEdgesVertexAttributeStyle.meshEdgesVertexAttributeColorMap(id);
-      const vertex_attribute = { name, item, minimum, maximum, colorMap };
-      if (!isMeshEdgesVertexAttributeValid(vertex_attribute)) {
-        return;
-      }
-      return meshEdgesVertexAttributeStyle.setMeshEdgesVertexAttribute(id, vertex_attribute);
-    }
-    if (type === "edge") {
-      const name = meshEdgesEdgeAttributeStyle.meshEdgesEdgeAttributeName(id);
-      const item = meshEdgesEdgeAttributeStyle.meshEdgesEdgeAttributeItem(id);
-      const [minimum, maximum] = meshEdgesEdgeAttributeStyle.meshEdgesEdgeAttributeRange(id);
-      const colorMap = meshEdgesEdgeAttributeStyle.meshEdgesEdgeAttributeColorMap(id);
-      const edge_attribute = { name, item, minimum, maximum, colorMap };
-      if (!isMeshEdgesEdgeAttributeValid(edge_attribute)) {
-        return;
-      }
-      return meshEdgesEdgeAttributeStyle.setMeshEdgesEdgeAttribute(id, edge_attribute);
-    }
-    throw new Error(`Unknown mesh edges coloring type: ${type}`);
-  }
-
-  function applyMeshEdgesStyle(id) {
-    return Promise.all([
-      meshEdgesVisibility.setMeshEdgesVisibility(id, meshEdgesVisibility.meshEdgesVisibility(id)),
-      meshEdgesWidthStyle.setMeshEdgesWidth(id, meshEdgesWidthStyle.meshEdgesWidth(id)),
-      setMeshEdgesActiveColoring(id, meshEdgesActiveColoring(id)),
-    ]);
-  }
-
-  return {
-    meshEdgesColoring,
-    meshEdgesActiveColoring,
-    setMeshEdgesActiveColoring,
-    applyMeshEdgesStyle,
-    ...meshEdgesCommonStyle,
-    ...meshEdgesVisibility,
-    ...meshEdgesColorStyle,
-    ...meshEdgesWidthStyle,
-    ...meshEdgesVertexAttributeStyle,
-    ...meshEdgesEdgeAttributeStyle,
-  };
-}

package/internal/stores/data_style/mesh/edges/vertex.js

@@ -1,196 +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 { useMeshEdgesCommonStyle } from "./common";
-import { useViewerStore } from "@ogw_front/stores/viewer";
-
-// Local constants
-const meshEdgesVertexAttributeSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.edges.attribute.vertex;
-function isMeshEdgesVertexAttributeValid({ 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 useMeshEdgesVertexAttributeStyle() {
-  const viewerStore = useViewerStore();
-  const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
-  function meshEdgesColoring(id) {
-    return meshEdgesCommonStyle.meshEdgesStyle(id).coloring;
-  }
-  function meshEdgesVertexAttribute(id) {
-    return meshEdgesColoring(id).vertex;
-  }
-  function meshEdgesVertexAttributeStoredConfig(id, name, item) {
-    const { storedConfigs } = meshEdgesVertexAttribute(id);
-    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 mutateMeshEdgesVertexStyle(id, values) {
-    return meshEdgesCommonStyle.mutateMeshEdgesStyle(id, {
-      coloring: {
-        vertex: values,
-      },
-    });
-  }
-  function setMeshEdgesVertexAttributeStoredConfig(id, name, item, config) {
-    return mutateMeshEdgesVertexStyle(id, {
-      storedConfigs: {
-        [name]: {
-          lastItem: item,
-          [item]: config,
-        },
-      },
-    });
-  }
-  function meshEdgesVertexAttributeName(id) {
-    return meshEdgesVertexAttribute(id).name;
-  }
-  function meshEdgesVertexAttributeLastItem(id, name) {
-    const { storedConfigs } = meshEdgesVertexAttribute(id);
-    if (storedConfigs && name in storedConfigs) {
-      return storedConfigs[name].lastItem;
-    }
-    return 0;
-  }
-  function meshEdgesVertexAttributeItem(id) {
-    const { item, name } = meshEdgesVertexAttribute(id);
-    return item ?? meshEdgesVertexAttributeLastItem(id, name);
-  }
-  function setMeshEdgesVertexAttribute(
-    id,
-    { name, item, minimum, maximum, colorMap, no_data_color = DEFAULT_NO_DATA_COLOR },
-  ) {
-    mutateMeshEdgesVertexStyle(id, {
-      name,
-      item,
-    });
-    setMeshEdgesVertexAttributeStoredConfig(id, name, item, {
-      minimum,
-      maximum,
-      colorMap,
-      no_data_color,
-    });
-    const points = getRGBPointsFromPreset(colorMap);
-    const schema = meshEdgesVertexAttributeSchemas.attribute;
-    const params = {
-      id,
-      name,
-      item,
-      points,
-      minimum,
-      maximum,
-      no_data_color,
-    };
-    return viewerStore.request({
-      schema,
-      params,
-    });
-  }
-  function applyVertexAttribute(id) {
-    const name = meshEdgesVertexAttributeName(id);
-    const item = meshEdgesVertexAttributeItem(id);
-    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name, item);
-    const attribute = {
-      name,
-      item,
-      minimum: storedConfig.minimum,
-      maximum: storedConfig.maximum,
-      colorMap: storedConfig.colorMap,
-      no_data_color: storedConfig.no_data_color,
-    };
-    if (isMeshEdgesVertexAttributeValid(attribute)) {
-      return setMeshEdgesVertexAttribute(id, attribute);
-    }
-  }
-  function setMeshEdgesVertexAttributeName(id, name) {
-    const item = meshEdgesVertexAttributeLastItem(id, name);
-    mutateMeshEdgesVertexStyle(id, {
-      name,
-      item,
-    });
-    return applyVertexAttribute(id);
-  }
-  function setMeshEdgesVertexAttributeItem(id, item) {
-    mutateMeshEdgesVertexStyle(id, {
-      item,
-    });
-    return applyVertexAttribute(id);
-  }
-  function meshEdgesVertexAttributeRange(id) {
-    const name = meshEdgesVertexAttributeName(id);
-    const item = meshEdgesVertexAttributeItem(id);
-    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name, item);
-    return [storedConfig.minimum, storedConfig.maximum];
-  }
-  function setMeshEdgesVertexAttributeRange(id, minimum, maximum) {
-    const name = meshEdgesVertexAttributeName(id);
-    const item = meshEdgesVertexAttributeItem(id);
-    setMeshEdgesVertexAttributeStoredConfig(id, name, item, {
-      minimum,
-      maximum,
-    });
-    return applyVertexAttribute(id);
-  }
-  function meshEdgesVertexAttributeColorMap(id) {
-    const name = meshEdgesVertexAttributeName(id);
-    const item = meshEdgesVertexAttributeItem(id);
-    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name, item);
-    return storedConfig.colorMap;
-  }
-  function setMeshEdgesVertexAttributeColorMap(id, colorMap) {
-    const name = meshEdgesVertexAttributeName(id);
-    const item = meshEdgesVertexAttributeItem(id);
-    setMeshEdgesVertexAttributeStoredConfig(id, name, item, {
-      colorMap,
-    });
-    return applyVertexAttribute(id);
-  }
-  function meshEdgesVertexAttributeNoDataColor(id) {
-    const name = meshEdgesVertexAttributeName(id);
-    const item = meshEdgesVertexAttributeItem(id);
-    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name, item);
-    return storedConfig.no_data_color;
-  }
-  async function setMeshEdgesVertexAttributeNoDataColor(id, no_data_color) {
-    const name = meshEdgesVertexAttributeName(id);
-    const item = meshEdgesVertexAttributeItem(id);
-    const storedConfig = meshEdgesVertexAttributeStoredConfig(id, name, item);
-    await setMeshEdgesVertexAttributeStoredConfig(id, name, item, {
-      ...storedConfig,
-      no_data_color,
-    });
-    return applyVertexAttribute(id);
-  }
-  return {
-    meshEdgesVertexAttributeName,
-    meshEdgesVertexAttributeItem,
-    meshEdgesVertexAttributeRange,
-    meshEdgesVertexAttributeColorMap,
-    meshEdgesVertexAttributeStoredConfig,
-    setMeshEdgesVertexAttribute,
-    setMeshEdgesVertexAttributeName,
-    setMeshEdgesVertexAttributeItem,
-    setMeshEdgesVertexAttributeRange,
-    setMeshEdgesVertexAttributeColorMap,
-    meshEdgesVertexAttributeNoDataColor,
-    setMeshEdgesVertexAttributeNoDataColor,
-  };
-}
-export { isMeshEdgesVertexAttributeValid, useMeshEdgesVertexAttributeStyle };

package/internal/stores/data_style/mesh/edges/visibility.js

@@ -1,34 +0,0 @@
-// Third party imports
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
-
-import { useMeshEdgesCommonStyle } from "./common";
-import { useViewerStore } from "@ogw_front/stores/viewer";
-
-// Local constants
-const schema = viewer_schemas.opengeodeweb_viewer.mesh.edges.visibility;
-
-export function useMeshEdgesVisibilityStyle() {
-  const viewerStore = useViewerStore();
-  const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
-
-  function meshEdgesVisibility(id) {
-    return meshEdgesCommonStyle.meshEdgesStyle(id).visibility;
-  }
-  function setMeshEdgesVisibility(id, visibility) {
-    const params = { id, visibility };
-    return viewerStore.request(
-      {
-        schema,
-        params,
-      },
-      {
-        response_function: () => meshEdgesCommonStyle.mutateMeshEdgesStyle(id, { visibility }),
-      },
-    );
-  }
-
-  return {
-    meshEdgesVisibility,
-    setMeshEdgesVisibility,
-  };
-}

package/internal/stores/data_style/mesh/edges/width.js

@@ -1,34 +0,0 @@
-// Third party imports
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
-
-import { useMeshEdgesCommonStyle } from "./common";
-import { useViewerStore } from "@ogw_front/stores/viewer";
-
-// Local constants
-const schema = viewer_schemas.opengeodeweb_viewer.mesh.edges.width;
-
-export function useMeshEdgesWidthStyle() {
-  const viewerStore = useViewerStore();
-  const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
-
-  function meshEdgesWidth(id) {
-    return meshEdgesCommonStyle.meshEdgesStyle(id).width;
-  }
-  function setMeshEdgesWidth(id, width) {
-    const params = { id, width };
-    return viewerStore.request(
-      {
-        schema,
-        params,
-      },
-      {
-        response_function: () => meshEdgesCommonStyle.mutateMeshEdgesStyle(id, { width }),
-      },
-    );
-  }
-
-  return {
-    meshEdgesWidth,
-    setMeshEdgesWidth,
-  };
-}

package/internal/stores/data_style/mesh/points/common.js

@@ -1,37 +0,0 @@
-import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
-
-export function useMeshPointsCommonStyle() {
-  const dataStyleState = useDataStyleState();
-
-  function mutateMeshPointsStyle(id, values) {
-    return dataStyleState.mutateStyle(id, {
-      points: values,
-    });
-  }
-
-  function mutateMeshPointsVisibility(response) {
-    return mutateMeshPointsStyle(response.id, { visibility: response.visibility });
-  }
-
-  function meshPointsStyle(id) {
-    return dataStyleState.getStyle(id).points;
-  }
-
-  function meshPointsColoring(id) {
-    return meshPointsStyle(id).coloring;
-  }
-
-  function mutateMeshPointsColoring(id, values) {
-    return mutateMeshPointsStyle(id, {
-      coloring: values,
-    });
-  }
-
-  return {
-    meshPointsStyle,
-    meshPointsColoring,
-    mutateMeshPointsColoring,
-    mutateMeshPointsStyle,
-    mutateMeshPointsVisibility,
-  };
-}

package/internal/stores/data_style/mesh/points/index.js

@@ -1,82 +0,0 @@
-// Third party imports
-
-// Local imports
-import { isMeshPointsVertexAttributeValid, useMeshPointsVertexAttributeStyle } from "./vertex";
-import { useMeshPointsColorStyle } from "./color";
-import { useMeshPointsCommonStyle } from "./common";
-import { useMeshPointsSizeStyle } from "./size";
-import { useMeshPointsVisibilityStyle } from "./visibility";
-
-// Local constants
-
-function useMeshPointsColoringStyle() {
-  const meshPointsCommonStyle = useMeshPointsCommonStyle();
-  const meshPointsColorStyle = useMeshPointsColorStyle();
-  const meshPointsVertexAttributeStyle = useMeshPointsVertexAttributeStyle();
-
-  function meshPointsColoring(id) {
-    return meshPointsCommonStyle.meshPointsColoring(id);
-  }
-
-  function meshPointsActiveColoring(id) {
-    return meshPointsColoring(id).active;
-  }
-
-  async function setMeshPointsActiveColoring(id, type) {
-    await meshPointsCommonStyle.mutateMeshPointsStyle(id, {
-      coloring: { active: type },
-    });
-    if (type === "constant") {
-      return meshPointsColorStyle.setMeshPointsColor(id, meshPointsColorStyle.meshPointsColor(id));
-    }
-    if (type === "vertex") {
-      const name = meshPointsVertexAttributeStyle.meshPointsVertexAttributeName(id);
-      const item = meshPointsVertexAttributeStyle.meshPointsVertexAttributeItem(id);
-      const [minimum, maximum] = meshPointsVertexAttributeStyle.meshPointsVertexAttributeRange(id);
-      const colorMap = meshPointsVertexAttributeStyle.meshPointsVertexAttributeColorMap(id);
-      const vertex_attribute = { name, item, minimum, maximum, colorMap };
-      if (!isMeshPointsVertexAttributeValid(vertex_attribute)) {
-        return;
-      }
-      return meshPointsVertexAttributeStyle.setMeshPointsVertexAttribute(id, vertex_attribute);
-    }
-    throw new Error(`Unknown mesh points coloring type: ${type}`);
-  }
-
-  return {
-    meshPointsColoring,
-    meshPointsActiveColoring,
-    setMeshPointsActiveColoring,
-    ...meshPointsColorStyle,
-    ...meshPointsVertexAttributeStyle,
-  };
-}
-
-export function useMeshPointsStyle() {
-  const meshPointsCommonStyle = useMeshPointsCommonStyle();
-  const meshPointsVisibility = useMeshPointsVisibilityStyle();
-  const meshPointsSizeStyle = useMeshPointsSizeStyle();
-  const meshPointsColoringStyle = useMeshPointsColoringStyle();
-
-  function applyMeshPointsStyle(id) {
-    return Promise.all([
-      meshPointsVisibility.setMeshPointsVisibility(
-        id,
-        meshPointsVisibility.meshPointsVisibility(id),
-      ),
-      meshPointsSizeStyle.setMeshPointsSize(id, meshPointsSizeStyle.meshPointsSize(id)),
-      meshPointsColoringStyle.setMeshPointsActiveColoring(
-        id,
-        meshPointsColoringStyle.meshPointsActiveColoring(id),
-      ),
-    ]);
-  }
-
-  return {
-    ...meshPointsCommonStyle,
-    ...meshPointsColoringStyle,
-    applyMeshPointsStyle,
-    ...meshPointsVisibility,
-    ...meshPointsSizeStyle,
-  };
-}

package/internal/stores/data_style/mesh/points/size.js

@@ -1,35 +0,0 @@
-// Third party imports
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
-
-// Local imports
-import { useMeshPointsCommonStyle } from "./common";
-import { useViewerStore } from "@ogw_front/stores/viewer";
-
-// Local constants
-const schema = viewer_schemas.opengeodeweb_viewer.mesh.points.size;
-
-export function useMeshPointsSizeStyle() {
-  const viewerStore = useViewerStore();
-  const meshPointsCommonStyle = useMeshPointsCommonStyle();
-
-  function meshPointsSize(id) {
-    return meshPointsCommonStyle.meshPointsStyle(id).size;
-  }
-  function setMeshPointsSize(id, size) {
-    const params = { id, size };
-    return viewerStore.request(
-      {
-        schema,
-        params,
-      },
-      {
-        response_function: () => meshPointsCommonStyle.mutateMeshPointsStyle(id, { size }),
-      },
-    );
-  }
-
-  return {
-    meshPointsSize,
-    setMeshPointsSize,
-  };
-}