vease 1.52.0-rc.8 → 1.52.0

package/.build/tests/e2e/utils/camera_interaction.js

@@ -105,17 +105,19 @@ async function toggleShrinkFilter(window) {
 	await window.getByTestId("shrinkFilterButton").click();
 	await waitForActionSettled(window);
 }
-async function setShrinkFactor(window, shrinkFactorValue) {
-	const slider = window.getByTestId("shrinkFactorSlider");
+async function setSliderRatio(window, sliderTestId, ratio) {
+	const slider = window.getByTestId(sliderTestId);
 	const box = await slider.boundingBox();
-	if (!box) throw new Error("Could not get bounding box of the shrink factor slider.");
-	const clickX = box.width * shrinkFactorValue;
+	if (!box) throw new Error(`Could not get bounding box of the ${sliderTestId} slider.`);
 	await slider.click({ position: {
-		x: clickX,
+		x: box.width * ratio,
 		y: box.height / 2
 	} });
 	await waitForActionSettled(window);
 }
+async function setShrinkFactor(window, shrinkFactorValue) {
+	await setSliderRatio(window, "shrinkFactorSlider", shrinkFactorValue);
+}
 async function resetShrinkFilter(window) {
 	await window.getByTestId("resetShrinkButton").click();
 	await waitForActionSettled(window);
@@ -133,6 +135,21 @@ async function selectShrinkDatasets(window, datasetName, index = 0) {
 	await select.click();
 	await waitForActionSettled(window);
 }
+async function toggleExplodeFilter(window) {
+	await window.getByTestId("explodeFilterButton").click();
+	await waitForActionSettled(window);
+}
+async function setExplodeFactor(window, explodeFactorValue) {
+	await setSliderRatio(window, "explodeFactorSlider", explodeFactorValue);
+}
+async function resetExplodeFilter(window) {
+	await window.getByTestId("resetExplodeButton").click();
+	await waitForActionSettled(window);
+}
+async function removeExplodeFilter(window) {
+	await window.getByTestId("removeExplodeButton").click();
+	await waitForActionSettled(window);
+}
 async function toggleThresholdFilter(window) {
 	await window.getByTestId("thresholdFilterButton").click();
 	await waitForActionSettled(window);
@@ -207,4 +224,4 @@ async function drawZoomBox(window, deltaX, deltaY) {
 	await expect(window.getByTestId("zoomBoxActiveChip")).toBeHidden();
 }
 //#endregion
-export { activateZoomToBox, clearRuler, closeCameraManager, drawZoomBox, ensureHighlightMenuOpen, removeThresholdFilter, resetCamera, resetShrinkFilter, resetThresholdFilter, restoreCameraPosition, rotateCamera, saveCameraPosition, selectCameraOrientation, selectShrinkDatasets, selectThresholdBlockPolyhedron, selectThresholdCellAttribute, setRulerPointInput, setShrinkFactor, setThresholdMinimum, setZScaling, toggleCameraManager, toggleCameraOrientation, toggleCenterOnClick, toggleGridScale, toggleRuler, toggleRulerSnap, toggleShrinkFilter, toggleShrinkTargetAllVisible, toggleThresholdFilter };
+export { activateZoomToBox, clearRuler, closeCameraManager, drawZoomBox, ensureHighlightMenuOpen, removeExplodeFilter, removeThresholdFilter, resetCamera, resetExplodeFilter, resetShrinkFilter, resetThresholdFilter, restoreCameraPosition, rotateCamera, saveCameraPosition, selectCameraOrientation, selectShrinkDatasets, selectThresholdBlockPolyhedron, selectThresholdCellAttribute, setExplodeFactor, setRulerPointInput, setShrinkFactor, setThresholdMinimum, setZScaling, toggleCameraManager, toggleCameraOrientation, toggleCenterOnClick, toggleExplodeFilter, toggleGridScale, toggleRuler, toggleRulerSnap, toggleShrinkFilter, toggleShrinkTargetAllVisible, toggleThresholdFilter };

package/.build/tests/e2e/utils/fixtures.js

@@ -18,7 +18,7 @@ const test = test$1.extend({
 	screenshotMask: [async ({}, use) => {
 		await use({ locators: [] });
 	}, { scope: "test" }],
-	window: [async ({ mode, playwright, browserName, headless, channel, launchOptions }, use, workerInfo) => {
+	app: [async ({ mode, playwright, browserName, headless, channel, launchOptions }, use, workerInfo) => {
 		const configPath = fs.mkdtempSync(path.join(os.tmpdir(), `vease-e2e-worker${workerInfo.parallelIndex}-`));
 		process.env.XDG_CONFIG_HOME = configPath;
 		process.env.APPDATA = configPath;
@@ -29,14 +29,30 @@ const test = test$1.extend({
 				channel
 			});
 		}
-		const { window, cleanup } = await navigateToApp(mode, launchBrowser);
-		await use(window);
-		await cleanup();
+		const app = {
+			...await navigateToApp(mode, launchBrowser),
+			restart: async () => {
+				await app.cleanup();
+				const { window, cleanup, electronApp } = await navigateToApp(mode, launchBrowser);
+				app.window = window;
+				app.cleanup = cleanup;
+				app.electronApp = electronApp;
+				return window;
+			}
+		};
+		await use(app);
+		await app.cleanup();
 		fs.rmSync(configPath, {
 			recursive: true,
 			force: true
 		});
 	}, { scope: "worker" }],
+	restartApp: [async ({ app }, use) => {
+		await use(app.restart);
+	}, { scope: "worker" }],
+	window: [async ({ app }, use) => {
+		await use(app.window);
+	}, { scope: "worker" }],
 	logTestProgress: [async ({}, use, testInfo) => {
 		const name = `${path.basename(testInfo.file)} › ${testInfo.title}`;
 		consola.info(`\u001B[33m[START]\u001B[0m ${name}`);
@@ -47,8 +63,9 @@ const test = test$1.extend({
 		const duration = ((Date.now() - start) / MILLISECONDS_PER_SECOND).toFixed(2);
 		consola.info(`\u001B[35m[END]\u001B[0m ${name} : ${statusColor}TEST ${status}\u001B[0m (${duration}s)`);
 	}, { auto: true }],
-	autoScreenshot: [async ({ window, screenshotMask }, use, testInfo) => {
+	autoScreenshot: [async ({ app, screenshotMask }, use, testInfo) => {
 		await use(void 0);
+		const { window } = app;
 		if (testInfo.status === testInfo.expectedStatus) await expect(window).toHaveScreenshot({ mask: [window.getByTestId("accountNavButton"), ...screenshotMask.locators] });
 	}, { auto: true }]
 });

package/.build/tests/e2e/utils/navigate.js

@@ -169,6 +169,7 @@ async function navigateToApp(mode, launchBrowser) {
 		await firstWindow.waitForFunction(() => document.readyState === "complete");
 		return {
 			window: firstWindow,
+			electronApp,
 			cleanup: async () => {
 				await electronApp.close();
 			}

package/.build/tests/e2e/utils/project_interaction.js

@@ -1,16 +1,45 @@
 import { waitForActionSettled } from "./wait_for_action_settled.js";
+import { closeFeedbackSnackbar } from "./app_interaction.js";
+import { expect } from "@playwright/test";
 //#region tests/e2e/utils/project_interaction.ts
-async function exportProject(window) {
+const importProjectTimeout = 2e4;
+const downloadTimeout = 3e4;
+async function saveNextElectronDownload(electronApp, savePath, trigger) {
+	await electronApp.evaluate(({ session }, filePath) => {
+		globalThis.e2eDownloadState = "pending";
+		session.defaultSession.once("will-download", (_event, item) => {
+			item.setSavePath(filePath);
+			item.once("done", (_doneEvent, state) => {
+				globalThis.e2eDownloadState = state;
+			});
+		});
+	}, savePath);
+	await trigger();
+	async function getDownloadState() {
+		return await electronApp.evaluate(() => globalThis.e2eDownloadState);
+	}
+	await expect.poll(getDownloadState, { timeout: downloadTimeout }).toBe("completed");
+}
+async function exportProject(window, savePath, electronApp) {
 	await window.getByTestId("projectMenuButton").click();
 	await waitForActionSettled(window);
-	await window.getByTestId("exportProjectButton").click();
+	const exportProjectButton = window.getByTestId("exportProjectButton");
+	if (electronApp) await saveNextElectronDownload(electronApp, savePath, async () => {
+		await exportProjectButton.click();
+	});
+	else {
+		const [download] = await Promise.all([window.waitForEvent("download"), exportProjectButton.click()]);
+		await download.saveAs(savePath);
+	}
 	await waitForActionSettled(window);
+	await closeFeedbackSnackbar(window);
 }
 async function importProject(window, projectFilePath) {
 	await window.getByTestId("projectMenuButton").click();
 	await waitForActionSettled(window);
 	await window.getByTestId("importProjectInput").setInputFiles(projectFilePath);
-	await window.waitForTimeout(8e3);
+	await waitForActionSettled(window, importProjectTimeout);
+	await closeFeedbackSnackbar(window);
 }
 //#endregion
 export { exportProject, importProject };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vease",
-  "version": "1.52.0-rc.8",
+  "version": "1.52.0",
   "description": "Desktop and cloud software for data visualization",
   "keywords": [
     "Desktop",
@@ -84,12 +84,12 @@
     "@ai-sdk/vue": "4.0.93",
     "@fontsource/michroma": "5.2.6",
     "@fontsource/roboto": "5.2.10",
-    "@geode/cloud-api": "next",
-    "@geode/opengeodeweb-back": "next",
-    "@geode/opengeodeweb-front": "next",
-    "@geode/opengeodeweb-viewer": "next",
-    "@geode/vease-back": "next",
-    "@geode/vease-viewer": "next",
+    "@geode/cloud-api": "latest",
+    "@geode/opengeodeweb-back": "latest",
+    "@geode/opengeodeweb-front": "latest",
+    "@geode/opengeodeweb-viewer": "latest",
+    "@geode/vease-back": "latest",
+    "@geode/vease-viewer": "latest",
     "@nuxtjs/mcp-toolkit": "0.18.1",
     "ai": "7.0.93",
     "bowser": "2.14.1",

package/tests/e2e/utils/camera_interaction.ts

@@ -15,7 +15,6 @@ async function resetCamera(window: Page): Promise<void> {
 }
 
 const ROTATE_DRAG_STEPS = 20;
-
 // Vtk.js' RenderWindowInteractor turns a pointermove arriving more than 200ms after the previous one into a StartMouseMove, which InteractorStyleTrackballCamera ignores.
 // A skipped move mid-drag is caught up by the next handled one (rotation uses the delta from the last handled position), but a skipped final move is lost for good.
 // On slow runners (Windows + swiftshader) the last step regularly lands late, leaving the camera one step short of the requested angle.
@@ -145,17 +144,20 @@ async function toggleShrinkFilter(window: Page): Promise<void> {
   await waitForActionSettled(window);
 }
 
-async function setShrinkFactor(window: Page, shrinkFactorValue: number): Promise<void> {
-  const slider = window.getByTestId("shrinkFactorSlider");
+async function setSliderRatio(window: Page, sliderTestId: string, ratio: number): Promise<void> {
+  const slider = window.getByTestId(sliderTestId);
   const box = await slider.boundingBox();
   if (!box) {
-    throw new Error("Could not get bounding box of the shrink factor slider.");
+    throw new Error(`Could not get bounding box of the ${sliderTestId} slider.`);
   }
-  const clickX = box.width * shrinkFactorValue;
-  await slider.click({ position: { x: clickX, y: box.height / 2 } });
+  await slider.click({ position: { x: box.width * ratio, y: box.height / 2 } });
   await waitForActionSettled(window);
 }
 
+async function setShrinkFactor(window: Page, shrinkFactorValue: number): Promise<void> {
+  await setSliderRatio(window, "shrinkFactorSlider", shrinkFactorValue);
+}
+
 async function resetShrinkFilter(window: Page): Promise<void> {
   await window.getByTestId("resetShrinkButton").click();
   await waitForActionSettled(window);
@@ -179,6 +181,25 @@ async function selectShrinkDatasets(window: Page, datasetName: string, index = 0
   await waitForActionSettled(window);
 }
 
+async function toggleExplodeFilter(window: Page): Promise<void> {
+  await window.getByTestId("explodeFilterButton").click();
+  await waitForActionSettled(window);
+}
+
+async function setExplodeFactor(window: Page, explodeFactorValue: number): Promise<void> {
+  await setSliderRatio(window, "explodeFactorSlider", explodeFactorValue);
+}
+
+async function resetExplodeFilter(window: Page): Promise<void> {
+  await window.getByTestId("resetExplodeButton").click();
+  await waitForActionSettled(window);
+}
+
+async function removeExplodeFilter(window: Page): Promise<void> {
+  await window.getByTestId("removeExplodeButton").click();
+  await waitForActionSettled(window);
+}
+
 async function toggleThresholdFilter(window: Page): Promise<void> {
   await window.getByTestId("thresholdFilterButton").click();
   await waitForActionSettled(window);
@@ -308,6 +329,10 @@ export {
   resetShrinkFilter,
   toggleShrinkTargetAllVisible,
   selectShrinkDatasets,
+  toggleExplodeFilter,
+  setExplodeFactor,
+  resetExplodeFilter,
+  removeExplodeFilter,
   toggleThresholdFilter,
   selectThresholdCellAttribute,
   selectThresholdBlockPolyhedron,

package/tests/e2e/utils/fixtures.ts

@@ -7,6 +7,7 @@ import path from "node:path";
 import type { Browser, Locator, Page } from "@playwright/test";
 // oxlint-disable-next-line eslint/no-duplicate-imports
 import { test as base, expect } from "@playwright/test";
+import type { ElectronApplication } from "playwright";
 import { consola } from "consola";
 
 // Local imports
@@ -18,9 +19,19 @@ interface ScreenshotMask {
   locators: Locator[];
 }
 
+interface RunningApp {
+  window: Page;
+  cleanup: () => Promise<void>;
+  // Only set in DESKTOP mode
+  electronApp?: ElectronApplication;
+  restart: () => Promise<Page>;
+}
+
 interface WorkerFixtures {
   mode: string;
   suiteId: string;
+  app: RunningApp;
+  restartApp: () => Promise<Page>;
   window: Page;
 }
 
@@ -43,7 +54,8 @@ const test = base.extend<TestFixtures, WorkerFixtures>({
     { scope: "test" },
   ],
 
-  window: [
+  // Mutable so restartApp can swap in a freshly launched app
+  app: [
     async (
       { mode, playwright, browserName, headless, channel, launchOptions },
       use,
@@ -64,14 +76,40 @@ const test = base.extend<TestFixtures, WorkerFixtures>({
         });
         return browser;
       }
-      const { window, cleanup } = await navigateToApp(mode, launchBrowser);
-      await use(window);
-      await cleanup();
+      const app: RunningApp = {
+        ...(await navigateToApp(mode, launchBrowser)),
+        restart: async (): Promise<Page> => {
+          await app.cleanup();
+          const { window, cleanup, electronApp } = await navigateToApp(mode, launchBrowser);
+          app.window = window;
+          app.cleanup = cleanup;
+          app.electronApp = electronApp;
+          return window;
+        },
+      };
+      await use(app);
+      await app.cleanup();
       fs.rmSync(configPath, { recursive: true, force: true });
     },
     { scope: "worker" },
   ],
 
+  // Kills the running app and launches a new one, like a user closing and reopening it
+  restartApp: [
+    async ({ app }, use): Promise<void> => {
+      await use(app.restart);
+    },
+    { scope: "worker" },
+  ],
+
+  // Page of the app launched with the worker: after restartApp, use the returned page or app.window
+  window: [
+    async ({ app }, use): Promise<void> => {
+      await use(app.window);
+    },
+    { scope: "worker" },
+  ],
+
   logTestProgress: [
     // oxlint-disable-next-line no-empty-pattern
     async ({}, use, testInfo): Promise<void> => {
@@ -90,8 +128,10 @@ const test = base.extend<TestFixtures, WorkerFixtures>({
   ],
 
   autoScreenshot: [
-    async ({ window, screenshotMask }, use, testInfo): Promise<void> => {
+    async ({ app, screenshotMask }, use, testInfo): Promise<void> => {
       await use(undefined);
+      // Read at teardown: the test may have restarted the app
+      const { window } = app;
       if (testInfo.status === testInfo.expectedStatus) {
         // The account icon depends on login state (only cloud is logged in)
         await expect(window).toHaveScreenshot({

package/tests/e2e/utils/navigate.ts

@@ -218,7 +218,7 @@ async function newBrowserPage(browser: Browser): Promise<Page> {
 async function navigateToApp(
   mode: string,
   launchBrowser: () => Promise<Browser>,
-): Promise<{ window: Page; cleanup: () => Promise<void> }> {
+): Promise<{ window: Page; cleanup: () => Promise<void>; electronApp?: ElectronApplication }> {
   consola.info(`Testing app in ${mode} mode`);
   // The desktop app is driven through Electron: no browser is launched
   if (mode === "DESKTOP") {
@@ -227,6 +227,7 @@ async function navigateToApp(
     await firstWindow.waitForFunction(() => document.readyState === "complete");
     return {
       window: firstWindow,
+      electronApp,
       cleanup: async () => {
         await electronApp.close();
       },

package/tests/e2e/utils/project_interaction.ts

@@ -1,11 +1,58 @@
-import type { Page } from "@playwright/test";
+import { type Page, expect } from "@playwright/test";
+import type { ElectronApplication } from "playwright";
+import { closeFeedbackSnackbar } from "./app_interaction";
 import { waitForActionSettled } from "./wait_for_action_settled";
 
-async function exportProject(window: Page): Promise<void> {
+const importProjectTimeout = 20_000;
+const downloadTimeout = 30_000;
+
+declare global {
+  var e2eDownloadState: string | undefined;
+}
+
+async function saveNextElectronDownload(
+  electronApp: ElectronApplication,
+  savePath: string,
+  trigger: () => Promise<void>,
+): Promise<void> {
+  await electronApp.evaluate(({ session }, filePath) => {
+    globalThis.e2eDownloadState = "pending";
+    session.defaultSession.once("will-download", (_event, item) => {
+      item.setSavePath(filePath);
+      item.once("done", (_doneEvent, state) => {
+        globalThis.e2eDownloadState = state;
+      });
+    });
+  }, savePath);
+  await trigger();
+  async function getDownloadState(): Promise<string | undefined> {
+    const state = await electronApp.evaluate(() => globalThis.e2eDownloadState);
+    return state;
+  }
+  await expect.poll(getDownloadState, { timeout: downloadTimeout }).toBe("completed");
+}
+
+async function exportProject(
+  window: Page,
+  savePath: string,
+  electronApp?: ElectronApplication,
+): Promise<void> {
   await window.getByTestId("projectMenuButton").click();
   await waitForActionSettled(window);
-  await window.getByTestId("exportProjectButton").click();
+  const exportProjectButton = window.getByTestId("exportProjectButton");
+  if (electronApp) {
+    await saveNextElectronDownload(electronApp, savePath, async () => {
+      await exportProjectButton.click();
+    });
+  } else {
+    const [download] = await Promise.all([
+      window.waitForEvent("download"),
+      exportProjectButton.click(),
+    ]);
+    await download.saveAs(savePath);
+  }
   await waitForActionSettled(window);
+  await closeFeedbackSnackbar(window);
 }
 
 async function importProject(window: Page, projectFilePath: string): Promise<void> {
@@ -13,8 +60,8 @@ async function importProject(window: Page, projectFilePath: string): Promise<voi
   await waitForActionSettled(window);
   const fileInput = window.getByTestId("importProjectInput");
   await fileInput.setInputFiles(projectFilePath);
-  const importTimeout = 8000;
-  await window.waitForTimeout(importTimeout);
+  await waitForActionSettled(window, importProjectTimeout);
+  await closeFeedbackSnackbar(window);
 }
 
 export { exportProject, importProject };