@geode/opengeodeweb-front 10.22.1 → 10.23.0-rc.1

package/tests/integration/stores/data_style/model/blocks.nuxt.test.js

@@ -90,6 +90,78 @@ describe("model blocks", () => {
       expect(viewerStore.status).toBe(Status.CONNECTED);
     });
   });
+  describe("blocks vertex attribute", () => {
+    test("coloring vertex attribute", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const block_ids = await dataStore.getBlocksGeodeIds(id);
+      const block_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, block_ids);
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelBlocksVertexAttributeName(id, block_ids, "points");
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      await sleep(SLEEP_MS);
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_blocks_schemas.attribute.vertex.name,
+          params: {
+            id,
+            block_ids: block_viewer_ids,
+            name: "points",
+          },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      );
+      for (const block_id of block_ids) {
+        expect(dataStyleStore.modelBlocksVertexAttributeName(id, block_id)).toBe("points");
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+
+  describe("blocks polyhedron attribute", () => {
+    test("coloring polyhedron attribute", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const block_ids = await dataStore.getBlocksGeodeIds(id);
+      const block_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, block_ids);
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelBlocksPolyhedronAttributeName(
+        id,
+        block_ids,
+        "test_attribute",
+      );
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      await sleep(SLEEP_MS);
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_blocks_schemas.attribute.polyhedron.name,
+          params: {
+            id,
+            block_ids: block_viewer_ids,
+            name: "test_attribute",
+          },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      );
+      for (const block_id of block_ids) {
+        expect(dataStyleStore.modelBlocksPolyhedronAttributeName(id, block_id)).toBe(
+          "test_attribute",
+        );
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+
   describe("blocks style", () => {
     test("blocks apply style", async () => {
       const dataStyleStore = useDataStyleStore();

package/tests/integration/stores/data_style/model/corners.nuxt.test.js

@@ -94,6 +94,39 @@ describe("model corners", () => {
     });
   });
 
+  describe("corners vertex attribute", () => {
+    test("coloring vertex attribute", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const corner_ids = await dataStore.getCornersGeodeIds(id);
+      const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, corner_ids);
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelCornersVertexAttributeName(id, corner_ids, "points");
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      await sleep(SLEEP_MS);
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_corners_schemas.attribute.vertex.name,
+          params: {
+            id,
+            block_ids: corner_viewer_ids,
+            name: "points",
+          },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      );
+      for (const corner_id of corner_ids) {
+        expect(dataStyleStore.modelCornersVertexAttributeName(id, corner_id)).toBe("points");
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+
   describe("corner style", () => {
     test("corners apply style", async () => {
       const dataStyleStore = useDataStyleStore();

package/tests/integration/stores/data_style/model/lines.nuxt.test.js

@@ -94,6 +94,72 @@ describe("model lines", () => {
       expect(viewerStore.status).toBe(Status.CONNECTED);
     });
   });
+  describe("lines vertex attribute", () => {
+    test("coloring vertex attribute", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const line_ids = await dataStore.getLinesGeodeIds(id);
+      const lines_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, line_ids);
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelLinesVertexAttributeName(id, line_ids, "points");
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      await sleep(SLEEP_MS);
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_lines_schemas.attribute.vertex.name,
+          params: {
+            id,
+            block_ids: lines_viewer_ids,
+            name: "points",
+          },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      );
+      for (const line_id of line_ids) {
+        expect(dataStyleStore.modelLinesVertexAttributeName(id, line_id)).toBe("points");
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+
+  describe("lines edge attribute", () => {
+    test("coloring edge attribute", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const line_ids = await dataStore.getLinesGeodeIds(id);
+      const lines_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, line_ids);
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelLinesEdgeAttributeName(id, line_ids, "test_attribute");
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      await sleep(SLEEP_MS);
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_lines_schemas.attribute.edge.name,
+          params: {
+            id,
+            block_ids: lines_viewer_ids,
+            name: "test_attribute",
+          },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      );
+      for (const line_id of line_ids) {
+        expect(dataStyleStore.modelLinesEdgeAttributeName(id, line_id)).toBe("test_attribute");
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+
   describe("lines style", () => {
     test("lines apply style", async () => {
       const dataStyleStore = useDataStyleStore();

package/tests/integration/stores/data_style/model/surfaces.nuxt.test.js

@@ -92,6 +92,78 @@ describe("model surfaces", () => {
       expect(viewerStore.status).toBe(Status.CONNECTED);
     });
   });
+  describe("surfaces vertex attribute", () => {
+    test("coloring vertex attribute", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const surface_ids = await dataStore.getSurfacesGeodeIds(id);
+      const surface_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, surface_ids);
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelSurfacesVertexAttributeName(id, surface_ids, "points");
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      await sleep(SLEEP_MS);
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_surfaces_schemas.attribute.vertex.name,
+          params: {
+            id,
+            block_ids: surface_viewer_ids,
+            name: "points",
+          },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      );
+      for (const surface_id of surface_ids) {
+        expect(dataStyleStore.modelSurfacesVertexAttributeName(id, surface_id)).toBe("points");
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+
+  describe("surfaces polygon attribute", () => {
+    test("coloring polygon attribute", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const surface_ids = await dataStore.getSurfacesGeodeIds(id);
+      const surface_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, surface_ids);
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelSurfacesPolygonAttributeName(
+        id,
+        surface_ids,
+        "test_attribute",
+      );
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      await sleep(SLEEP_MS);
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_surfaces_schemas.attribute.polygon.name,
+          params: {
+            id,
+            block_ids: surface_viewer_ids,
+            name: "test_attribute",
+          },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      );
+      for (const surface_id of surface_ids) {
+        expect(dataStyleStore.modelSurfacesPolygonAttributeName(id, surface_id)).toBe(
+          "test_attribute",
+        );
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+
   describe("surfaces style", () => {
     test("surfaces apply style", async () => {
       const dataStyleStore = useDataStyleStore();

package/app/utils/default_styles.js

@@ -1,327 +0,0 @@
-// Global variables
-const points_defaultVisibility = true;
-const edges_defaultVisibility = true;
-const cells_defaultVisibility = true;
-const polygons_defaultVisibility = true;
-const polyhedra_defaultVisibility = true;
-const points_defaultSize = 10;
-const points_defaultColor = { red: 20, green: 20, blue: 20, alpha: 1 };
-const edges_defaultWidth = 2;
-const edges_defaultColor = { red: 20, green: 20, blue: 20, alpha: 1 };
-const cells_defaultColor = { red: 255, green: 255, blue: 255, alpha: 1 };
-const polygons_defaultColor = { red: 255, green: 255, blue: 255, alpha: 1 };
-const polyhedra_defaultColor = { red: 255, green: 255, blue: 255, alpha: 1 };
-
-const corners_defaultVisibility = true;
-const corners_defaultColor = { red: 20, green: 20, blue: 20, alpha: 1 };
-const lines_defaultVisibility = true;
-const lines_defaultColor = { red: 20, green: 20, blue: 20, alpha: 1 };
-const surfaces_defaultVisibility = true;
-const surfaces_defaultColor = { red: 255, green: 255, blue: 255, alpha: 1 };
-const blocks_defaultVisibility = true;
-const blocks_defaultColor = { red: 255, green: 255, blue: 255, alpha: 1 };
-
-const DEFAULT_MODEL_COMPONENT_TYPE_COLORS = {
-  Corner: corners_defaultColor,
-  Line: lines_defaultColor,
-  Surface: surfaces_defaultColor,
-  Block: blocks_defaultColor,
-};
-
-const MESH_TYPES = ["Corner", "Line", "Surface", "Block"];
-
-// Mesh functions
-function meshPointsDefaultStyle(
-  visibility = points_defaultVisibility,
-  size = points_defaultSize,
-  color = points_defaultColor,
-) {
-  return {
-    visibility,
-    coloring: {
-      active: "color",
-      color,
-      vertex: {
-        name: undefined,
-        storedConfigs: {},
-      },
-    },
-    size,
-  };
-}
-
-function meshEdgesDefaultStyle(
-  visibility = edges_defaultVisibility,
-  width = edges_defaultWidth,
-  color = edges_defaultColor,
-) {
-  return {
-    visibility,
-    coloring: {
-      active: "color",
-      color,
-      edge: {
-        name: undefined,
-        storedConfigs: {},
-      },
-      vertex: {
-        name: undefined,
-        storedConfigs: {},
-      },
-    },
-    width,
-  };
-}
-
-function meshCellsDefaultStyle(visibility = cells_defaultVisibility, color = cells_defaultColor) {
-  return {
-    visibility,
-    coloring: {
-      active: "color",
-      cell: {
-        name: undefined,
-        storedConfigs: {},
-      },
-      color,
-      textures: undefined,
-      vertex: {
-        name: undefined,
-        storedConfigs: {},
-      },
-    },
-  };
-}
-
-function meshPolygonsDefaultStyle(
-  visibility = polygons_defaultVisibility,
-  color = polygons_defaultColor,
-) {
-  return {
-    visibility,
-    coloring: {
-      active: "color",
-      color,
-      textures: undefined,
-      polygon: {
-        name: undefined,
-        storedConfigs: {},
-      },
-      vertex: {
-        name: undefined,
-        storedConfigs: {},
-      },
-    },
-  };
-}
-
-function meshPolyhedraDefaultStyle(
-  visibility = polyhedra_defaultVisibility,
-  color = polyhedra_defaultColor,
-) {
-  return {
-    visibility,
-    coloring: {
-      active: "color",
-      color,
-      polyhedron: {
-        name: undefined,
-        storedConfigs: {},
-      },
-      vertex: {
-        name: undefined,
-        storedConfigs: {},
-      },
-    },
-  };
-}
-
-function pointSet_defaultStyle() {
-  return {
-    visibility: true,
-    points: meshPointsDefaultStyle(),
-  };
-}
-
-function edgedCurve_defaultStyle() {
-  return {
-    visibility: true,
-    points: meshPointsDefaultStyle(),
-    edges: meshEdgesDefaultStyle(),
-  };
-}
-
-function grid2d_defaultStyle() {
-  return {
-    visibility: true,
-    points: meshPointsDefaultStyle(false),
-    edges: meshEdgesDefaultStyle(false),
-    cells: meshCellsDefaultStyle(),
-  };
-}
-
-function grid3d_defaultStyle() {
-  return {
-    visibility: true,
-    points: meshPointsDefaultStyle(false),
-    edges: meshEdgesDefaultStyle(false),
-    cells: meshCellsDefaultStyle(),
-    polyhedra: meshPolyhedraDefaultStyle(),
-  };
-}
-function surface_defaultStyle() {
-  return {
-    visibility: true,
-    points: meshPointsDefaultStyle(false),
-    edges: meshEdgesDefaultStyle(false),
-    polygons: meshPolygonsDefaultStyle(),
-  };
-}
-
-function solid_defaultStyle() {
-  return {
-    visibility: true,
-    points: meshPointsDefaultStyle(false),
-    edges: meshEdgesDefaultStyle(false),
-    polygons: meshPolygonsDefaultStyle(),
-    polyhedra: meshPolyhedraDefaultStyle(),
-  };
-}
-
-// Model functions
-function modelCornersDefaultStyle(
-  visibility = corners_defaultVisibility,
-  color = corners_defaultColor,
-) {
-  return { visibility, color };
-}
-
-function modelLinesDefaultStyle(visibility = lines_defaultVisibility, color = lines_defaultColor) {
-  return { visibility, color };
-}
-
-function modelSurfacesDefaultStyle(
-  visibility = surfaces_defaultVisibility,
-  color = surfaces_defaultColor,
-) {
-  return { visibility, color };
-}
-
-function modelBlocksDefaultStyle(
-  visibility = blocks_defaultVisibility,
-  color = blocks_defaultColor,
-) {
-  return { visibility, color };
-}
-
-function modelPointsDefaultStyle(visibility = points_defaultVisibility, size = points_defaultSize) {
-  return { visibility, size };
-}
-
-function modelEdgesDefaultStyle(visibility = edges_defaultVisibility, width = edges_defaultWidth) {
-  return { visibility, width };
-}
-
-function brep_defaultStyle() {
-  return {
-    visibility: true,
-    corners: modelCornersDefaultStyle(),
-    lines: modelLinesDefaultStyle(),
-    surfaces: modelSurfacesDefaultStyle(),
-    blocks: modelBlocksDefaultStyle(),
-    points: modelPointsDefaultStyle(false, points_defaultSize),
-    edges: modelEdgesDefaultStyle(false, edges_defaultWidth),
-  };
-}
-
-function crossSection_defaultStyle() {
-  return {
-    visibility: true,
-    corners: modelCornersDefaultStyle(),
-    lines: modelLinesDefaultStyle(),
-    surfaces: modelSurfacesDefaultStyle(),
-    points: modelPointsDefaultStyle(false, points_defaultSize),
-    edges: modelEdgesDefaultStyle(false, edges_defaultWidth),
-  };
-}
-
-function structuralModel_defaultStyle() {
-  return {
-    visibility: true,
-    corners: modelCornersDefaultStyle(),
-    lines: modelLinesDefaultStyle(),
-    surfaces: modelSurfacesDefaultStyle(),
-    blocks: modelBlocksDefaultStyle(),
-    points: modelPointsDefaultStyle(false, points_defaultSize),
-    edges: modelEdgesDefaultStyle(false, edges_defaultWidth),
-  };
-}
-
-function section_defaultStyle() {
-  return {
-    visibility: true,
-    corners: modelCornersDefaultStyle(),
-    lines: modelLinesDefaultStyle(),
-    surfaces: modelSurfacesDefaultStyle(),
-    points: modelPointsDefaultStyle(false, points_defaultSize),
-    edges: modelEdgesDefaultStyle(false, edges_defaultWidth),
-  };
-}
-
-function implicitCrossSection_defaultStyle() {
-  return {
-    visibility: true,
-    corners: modelCornersDefaultStyle(),
-    lines: modelLinesDefaultStyle(),
-    surfaces: modelSurfacesDefaultStyle(),
-    points: modelPointsDefaultStyle(false, points_defaultSize),
-    edges: modelEdgesDefaultStyle(false, edges_defaultWidth),
-  };
-}
-
-function implicitStructuralModel_defaultStyle() {
-  return {
-    visibility: true,
-    corners: modelCornersDefaultStyle(),
-    lines: modelLinesDefaultStyle(),
-    surfaces: modelSurfacesDefaultStyle(),
-    blocks: modelBlocksDefaultStyle(),
-    points: modelPointsDefaultStyle(false, points_defaultSize),
-    edges: modelEdgesDefaultStyle(false, edges_defaultWidth),
-  };
-}
-
-function default_styles() {
-  return {
-    BRep: brep_defaultStyle(),
-    CrossSection: crossSection_defaultStyle(),
-    EdgedCurve2D: edgedCurve_defaultStyle(),
-    EdgedCurve3D: edgedCurve_defaultStyle(),
-    Graph: {},
-    HybridSolid3D: solid_defaultStyle(),
-    ImplicitCrossSection: implicitCrossSection_defaultStyle(),
-    ImplicitStructuralModel: implicitStructuralModel_defaultStyle(),
-    LightRegularGrid2D: grid2d_defaultStyle(),
-    LightRegularGrid3D: grid3d_defaultStyle(),
-    PointSet2D: pointSet_defaultStyle(),
-    PointSet3D: pointSet_defaultStyle(),
-    PolygonalSurface2D: surface_defaultStyle(),
-    PolygonalSurface3D: surface_defaultStyle(),
-    PolyhedralSolid3D: solid_defaultStyle(),
-    RasterImage2D: {},
-    RasterImage3D: {},
-    RegularGrid2D: grid2d_defaultStyle(),
-    RegularGrid3D: grid3d_defaultStyle(),
-    Section: section_defaultStyle(),
-    StructuralModel: structuralModel_defaultStyle(),
-    TetrahedralSolid3D: solid_defaultStyle(),
-    TriangulatedSurface2D: surface_defaultStyle(),
-    TriangulatedSurface3D: surface_defaultStyle(),
-    VertexSet: {},
-  };
-}
-
-function getDefaultStyle(type) {
-  return default_styles()[type];
-}
-
-export { getDefaultStyle, DEFAULT_MODEL_COMPONENT_TYPE_COLORS, MESH_TYPES };