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

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();
@@ -100,4 +172,50 @@ describe("model blocks", () => {
       expect(viewerStore.status).toBe(Status.CONNECTED);
     });
   });
+
+  describe("block component active coloring", () => {
+    test("coloring color", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const block_ids = await dataStore.getBlocksGeodeIds(id);
+      const [block_id] = block_ids;
+      const coloringName = "color";
+      const result = dataStyleStore.setModelComponentColorMode(id, block_id, coloringName);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(dataStyleStore.modelBlockColorMode(id, block_id)).toBe(coloringName);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+
+    test("coloring vertex", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const block_ids = await dataStore.getBlocksGeodeIds(id);
+      const [block_id] = block_ids;
+      await dataStyleStore.setModelBlocksVertexAttributeName(id, [block_id], "points");
+      const coloringName = "vertex";
+      const result = dataStyleStore.setModelComponentColorMode(id, block_id, coloringName);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(dataStyleStore.modelBlockColorMode(id, block_id)).toBe(coloringName);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+
+    test("coloring polyhedron", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const block_ids = await dataStore.getBlocksGeodeIds(id);
+      const [block_id] = block_ids;
+      await dataStyleStore.setModelBlocksPolyhedronAttributeName(id, [block_id], "test_attribute");
+      const coloringName = "polyhedron";
+      const result = dataStyleStore.setModelComponentColorMode(id, block_id, coloringName);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(dataStyleStore.modelBlockColorMode(id, block_id)).toBe(coloringName);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 });

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();
@@ -104,4 +137,35 @@ describe("model corners", () => {
       expect(viewerStore.status).toBe(Status.CONNECTED);
     });
   });
+
+  describe("corner component active coloring", () => {
+    test("coloring color", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const corner_ids = await dataStore.getCornersGeodeIds(id);
+      const [corner_id] = corner_ids;
+      const coloringName = "color";
+      const result = dataStyleStore.setModelComponentColorMode(id, corner_id, coloringName);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(dataStyleStore.modelCornerColorMode(id, corner_id)).toBe(coloringName);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+
+    test("coloring vertex", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const corner_ids = await dataStore.getCornersGeodeIds(id);
+      const [corner_id] = corner_ids;
+      await dataStyleStore.setModelCornersVertexAttributeName(id, [corner_id], "points");
+      const coloringName = "vertex";
+      const result = dataStyleStore.setModelComponentColorMode(id, corner_id, coloringName);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(dataStyleStore.modelCornerColorMode(id, corner_id)).toBe(coloringName);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 });

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();
@@ -104,4 +170,50 @@ describe("model lines", () => {
       expect(viewerStore.status).toBe(Status.CONNECTED);
     });
   });
+
+  describe("line component active coloring", () => {
+    test("coloring color", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const line_ids = await dataStore.getLinesGeodeIds(id);
+      const [line_id] = line_ids;
+      const coloringName = "color";
+      const result = dataStyleStore.setModelComponentColorMode(id, line_id, coloringName);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(dataStyleStore.modelLineColorMode(id, line_id)).toBe(coloringName);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+
+    test("coloring vertex", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const line_ids = await dataStore.getLinesGeodeIds(id);
+      const [line_id] = line_ids;
+      await dataStyleStore.setModelLinesVertexAttributeName(id, [line_id], "points");
+      const coloringName = "vertex";
+      const result = dataStyleStore.setModelComponentColorMode(id, line_id, coloringName);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(dataStyleStore.modelLineColorMode(id, line_id)).toBe(coloringName);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+
+    test("coloring edge", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const line_ids = await dataStore.getLinesGeodeIds(id);
+      const [line_id] = line_ids;
+      await dataStyleStore.setModelLinesEdgeAttributeName(id, [line_id], "test_attribute");
+      const coloringName = "edge";
+      const result = dataStyleStore.setModelComponentColorMode(id, line_id, coloringName);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(dataStyleStore.modelLineColorMode(id, line_id)).toBe(coloringName);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 });

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();
@@ -102,4 +174,50 @@ describe("model surfaces", () => {
       expect(viewerStore.status).toBe(Status.CONNECTED);
     });
   });
+
+  describe("surface component active coloring", () => {
+    test("coloring color", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const surface_ids = await dataStore.getSurfacesGeodeIds(id);
+      const [surface_id] = surface_ids;
+      const coloringName = "color";
+      const result = dataStyleStore.setModelComponentColorMode(id, surface_id, coloringName);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(dataStyleStore.modelSurfaceColorMode(id, surface_id)).toBe(coloringName);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+
+    test("coloring vertex", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const surface_ids = await dataStore.getSurfacesGeodeIds(id);
+      const [surface_id] = surface_ids;
+      await dataStyleStore.setModelSurfacesVertexAttributeName(id, [surface_id], "points");
+      const coloringName = "vertex";
+      const result = dataStyleStore.setModelComponentColorMode(id, surface_id, coloringName);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(dataStyleStore.modelSurfaceColorMode(id, surface_id)).toBe(coloringName);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+
+    test("coloring polygon", async () => {
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const surface_ids = await dataStore.getSurfacesGeodeIds(id);
+      const [surface_id] = surface_ids;
+      await dataStyleStore.setModelSurfacesPolygonAttributeName(id, [surface_id], "test_attribute");
+      const coloringName = "polygon";
+      const result = dataStyleStore.setModelComponentColorMode(id, surface_id, coloringName);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(dataStyleStore.modelSurfaceColorMode(id, surface_id)).toBe(coloringName);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 });