vease 1.48.0-rc.13 → 1.48.0-rc.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vease",
-  "version": "1.48.0-rc.13",
+  "version": "1.48.0-rc.15",
   "description": "Desktop and cloud software for data visualization",
   "keywords": [
     "Desktop",

package/tests/e2e/utils/app_interaction.js

@@ -1,7 +1,7 @@
 import { afterActionWait } from "./constants.js";
 //#region tests/e2e/utils/app_interaction.ts
-function moveMouseOutOfTheWay(window) {
-	return window.mouse.move(0, 0);
+async function moveMouseOutOfTheWay(window) {
+	await window.mouse.move(0, 0);
 }
 async function closeAllMenus(window) {
 	await window.keyboard.press("Escape");

package/tests/e2e/utils/app_interaction.ts

@@ -1,9 +1,10 @@
+import type { Page } from "@playwright/test";
 import { afterActionWait } from "./constants";
 
-function moveMouseOutOfTheWay(window) {
-  return window.mouse.move(0, 0);
+async function moveMouseOutOfTheWay(window: Page): Promise<void> {
+  await window.mouse.move(0, 0);
 }
-async function closeAllMenus(window) {
+async function closeAllMenus(window: Page): Promise<void> {
   await window.keyboard.press("Escape");
   await window.waitForTimeout(afterActionWait);
 }

package/tests/e2e/utils/camera_interaction.js

@@ -83,6 +83,7 @@ async function toggleShrinkFilter(window) {
 async function setShrinkFactor(window, shrinkFactorValue) {
 	const slider = window.getByTestId("shrinkFactorSlider");
 	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;
 	await slider.click({ position: {
 		x: clickX,

package/tests/e2e/utils/camera_interaction.ts

@@ -1,29 +1,31 @@
+import type { Page } from "@playwright/test";
+
 import { afterActionWait, dragElement, getHybridViewerCanvas } from "./viewer_interaction";
 import { closeAllMenus, moveMouseOutOfTheWay } from "./app_interaction";
 
-async function resetCamera(window) {
+async function resetCamera(window: Page): Promise<void> {
   await window.getByTestId("resetCameraButton").click();
   await moveMouseOutOfTheWay(window);
   await window.waitForTimeout(afterActionWait);
 }
 
-async function rotateCamera(window, deltaX, deltaY = 0) {
+async function rotateCamera(window: Page, deltaX: number, deltaY = 0): Promise<void> {
   const hybridViewerCanvas = getHybridViewerCanvas(window);
   await dragElement(window, hybridViewerCanvas, { deltaX, deltaY });
 }
 
-async function toggleCenterOnClick(window) {
+async function toggleCenterOnClick(window: Page): Promise<void> {
   await window.getByTestId("centerOnClickButton").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function toggleGridScale(window) {
+async function toggleGridScale(window: Page): Promise<void> {
   await closeAllMenus(window);
   await window.getByTestId("gridScaleButton").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function setZScaling(window, zScaleValue) {
+async function setZScaling(window: Page, zScaleValue: number): Promise<void> {
   await closeAllMenus(window);
   await window.getByTestId("zScalingButton").click();
   await window.waitForTimeout(afterActionWait);
@@ -42,12 +44,12 @@ async function setZScaling(window, zScaleValue) {
   await window.waitForTimeout(afterActionWait);
 }
 
-async function toggleCameraManager(window) {
+async function toggleCameraManager(window: Page): Promise<void> {
   await window.getByTestId("cameraManagerButton").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function saveCameraPosition(window, name) {
+async function saveCameraPosition(window: Page, name: string): Promise<void> {
   const input = window.getByTestId("cameraPositionNameInput").locator("input");
   await input.fill(name);
   await window.waitForTimeout(afterActionWait);
@@ -55,28 +57,28 @@ async function saveCameraPosition(window, name) {
   await window.waitForTimeout(afterActionWait);
 }
 
-async function closeCameraManager(window) {
+async function closeCameraManager(window: Page): Promise<void> {
   await window.getByTestId("closeCameraManagerButton").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function toggleCameraOrientation(window) {
+async function toggleCameraOrientation(window: Page): Promise<void> {
   await window.getByTestId("cameraOrientationButton").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function selectCameraOrientation(window, label) {
+async function selectCameraOrientation(window: Page, label: string): Promise<void> {
   const vtkKey = label.replace("+", "Plus").replace("-", "Minus");
   await window.getByTestId(`cameraOrientation${vtkKey}Button`).click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function restoreCameraPosition(window, name) {
+async function restoreCameraPosition(window: Page, name: string): Promise<void> {
   await window.getByTestId(`restoreCameraPosition${name}Button`).click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function ensureHighlightMenuOpen(window, childButtonTestId) {
+async function ensureHighlightMenuOpen(window: Page, childButtonTestId: string): Promise<void> {
   if (!(await window.getByTestId(childButtonTestId).isVisible())) {
     await window.getByTestId("highlightOnHoverButton").click();
     await window.waitForTimeout(afterActionWait);
@@ -87,32 +89,35 @@ async function ensureHighlightMenuOpen(window, childButtonTestId) {
   }
 }
 
-async function toggleShrinkFilter(window) {
+async function toggleShrinkFilter(window: Page): Promise<void> {
   await window.getByTestId("shrinkFilterButton").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function setShrinkFactor(window, shrinkFactorValue) {
+async function setShrinkFactor(window: Page, shrinkFactorValue: number): Promise<void> {
   const slider = window.getByTestId("shrinkFactorSlider");
   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;
   await slider.click({ position: { x: clickX, y: box.height / 2 } });
   await window.waitForTimeout(afterActionWait);
 }
 
-async function resetShrinkFilter(window) {
+async function resetShrinkFilter(window: Page): Promise<void> {
   await window.getByTestId("resetShrinkButton").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function toggleShrinkTargetAllVisible(window) {
+async function toggleShrinkTargetAllVisible(window: Page): Promise<void> {
   const switchElement = window.getByTestId("shrinkTargetAllVisibleSwitch");
   const checkbox = switchElement.getByRole("checkbox");
   await checkbox.click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function selectShrinkDatasets(window, datasetName, index = 0) {
+async function selectShrinkDatasets(window: Page, datasetName: string, index = 0): Promise<void> {
   const select = window.getByTestId("shrinkSelectedDatasetsSelect");
   await select.click();
   await window.waitForTimeout(afterActionWait);
@@ -123,20 +128,24 @@ async function selectShrinkDatasets(window, datasetName, index = 0) {
   await window.waitForTimeout(afterActionWait);
 }
 
-async function toggleRuler(window) {
+async function toggleRuler(window: Page): Promise<void> {
   await closeAllMenus(window);
   await window.getByTestId("rulerButton").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function toggleRulerSnap(window) {
+async function toggleRulerSnap(window: Page): Promise<void> {
   const switchElement = window.getByTestId("rulerSnapToggle");
   const checkbox = switchElement.getByRole("checkbox");
   await checkbox.click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function setRulerPointInput(window, pointIndex, coords) {
+async function setRulerPointInput(
+  window: Page,
+  pointIndex: number,
+  coords: number[],
+): Promise<void> {
   const card = window.getByTestId("rulerPointCard").nth(pointIndex - 1);
   for (let axis = 0; axis < coords.length; axis += 1) {
     const input = card.getByTestId("rulerPointCoordInput").nth(axis).locator("input");
@@ -147,7 +156,7 @@ async function setRulerPointInput(window, pointIndex, coords) {
   await window.waitForTimeout(afterActionWait);
 }
 
-async function clearRuler(window) {
+async function clearRuler(window: Page): Promise<void> {
   await window.getByTestId("rulerClearButton").click();
   await window.waitForTimeout(afterActionWait);
 }

package/tests/e2e/utils/clipping_planes_interaction.ts

@@ -1,16 +1,17 @@
+import type { Page } from "@playwright/test";
 import { afterActionWait } from "./viewer_interaction";
 
-async function toggleClippingPlanes(window) {
+async function toggleClippingPlanes(window: Page): Promise<void> {
   await window.getByTestId("clippingPlanesButton").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function invertPlaneNormal(window, planeIndex = 0) {
+async function invertPlaneNormal(window: Page, planeIndex = 0): Promise<void> {
   await window.getByTestId("invertNormalButton").nth(planeIndex).click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function setPlaneOrigin(window, planeIndex, origin) {
+async function setPlaneOrigin(window: Page, planeIndex: number, origin: number[]): Promise<void> {
   const card = window.getByTestId("planeCard").nth(planeIndex);
   for (let axis = 0; axis < origin.length; axis += 1) {
     const input = card.getByTestId("planeOriginInput").nth(axis).locator("input");
@@ -21,7 +22,7 @@ async function setPlaneOrigin(window, planeIndex, origin) {
   await window.waitForTimeout(afterActionWait);
 }
 
-async function setPlaneNormal(window, planeIndex, normal) {
+async function setPlaneNormal(window: Page, planeIndex: number, normal: number[]): Promise<void> {
   const card = window.getByTestId("planeCard").nth(planeIndex);
   for (let axis = 0; axis < normal.length; axis += 1) {
     const input = card.getByTestId("planeNormalInput").nth(axis).locator("input");
@@ -32,17 +33,17 @@ async function setPlaneNormal(window, planeIndex, normal) {
   await window.waitForTimeout(afterActionWait);
 }
 
-async function addClippingPlane(window) {
+async function addClippingPlane(window: Page): Promise<void> {
   await window.getByTestId("addPlaneButton").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function toggleTargetAllVisible(window) {
+async function toggleTargetAllVisible(window: Page): Promise<void> {
   await window.getByTestId("targetAllVisibleSwitch").getByRole("checkbox").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function selectClippingDatasets(window, datasetName, index = 0) {
+async function selectClippingDatasets(window: Page, datasetName: string, index = 0): Promise<void> {
   await window.getByTestId("selectedDatasetsSelect").click();
   await window.waitForTimeout(afterActionWait);
   await window.getByRole("option", { name: datasetName }).nth(index).click();

package/tests/e2e/utils/create_objects.ts

@@ -1,10 +1,18 @@
+import type { Locator, Page } from "@playwright/test";
+
 import { afterActionWait, getHybridViewerCanvas } from "./viewer_interaction";
 
-function getCreateToolsPanelButton(window) {
+interface PointCoords {
+  x: number;
+  y: number;
+  z: number;
+}
+
+function getCreateToolsPanelButton(window: Page): Locator {
   return window.getByTestId("createToolsPanel");
 }
 
-async function openCreateToolsPanel(window) {
+async function openCreateToolsPanel(window: Page): Promise<void> {
   const createToolsPanelButton = getCreateToolsPanelButton(window);
   const isOpen = await createToolsPanelButton.isVisible();
   if (!isOpen) {
@@ -13,7 +21,7 @@ async function openCreateToolsPanel(window) {
   }
 }
 
-async function closeCreateToolsPanel(window) {
+async function closeCreateToolsPanel(window: Page): Promise<void> {
   const createToolsPanelButton = getCreateToolsPanelButton(window);
   const isOpen = await createToolsPanelButton.isVisible();
   if (isOpen) {
@@ -22,13 +30,19 @@ async function closeCreateToolsPanel(window) {
   }
 }
 
-async function selectCreateTool(window, toolId) {
+async function selectCreateTool(window: Page, toolId: string): Promise<void> {
   const createToolButton = window.getByTestId(`createToolCard-${toolId}`);
   await createToolButton.click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function fillPointCoords(window, index, x, y, z) {
+async function fillPointCoords(
+  window: Page,
+  index: number,
+  x: number,
+  y: number,
+  z: number,
+): Promise<void> {
   const row = window.getByTestId(`point-${index}`);
   const inputs = row.locator("input");
   await inputs.nth(0).fill(x.toString());
@@ -39,13 +53,13 @@ async function fillPointCoords(window, index, x, y, z) {
   await window.waitForTimeout(afterActionWait);
 }
 
-async function addPointRow(window) {
+async function addPointRow(window: Page): Promise<void> {
   await window.getByTestId("addPointButton").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function fillPointsCoords(window, coords) {
-  async function fillNext(index) {
+async function fillPointsCoords(window: Page, coords: PointCoords[]): Promise<void> {
+  async function fillNext(index: number): Promise<void> {
     if (index >= coords.length) {
       return;
     }
@@ -60,12 +74,12 @@ async function fillPointsCoords(window, coords) {
   await fillNext(0);
 }
 
-async function clickPickButton(window) {
+async function clickPickButton(window: Page): Promise<void> {
   await window.getByTestId("pickButton").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function pickPointInViewer(window, x, y) {
+async function pickPointInViewer(window: Page, x: number, y: number): Promise<void> {
   const hybridViewerCanvas = getHybridViewerCanvas(window);
   await hybridViewerCanvas.click({
     position: { x, y },
@@ -73,17 +87,17 @@ async function pickPointInViewer(window, x, y) {
   await window.waitForTimeout(afterActionWait);
 }
 
-async function submitCreateObject(window) {
+async function submitCreateObject(window: Page): Promise<void> {
   await window.getByTestId("submitButton").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function closePickingBanner(window) {
+async function closePickingBanner(window: Page): Promise<void> {
   await window.getByTestId("pickingActiveChip").click();
   await window.waitForTimeout(afterActionWait);
 }
 
-async function toggleClosedCurve(window) {
+async function toggleClosedCurve(window: Page): Promise<void> {
   await window.getByTestId("closedCurveCheckbox").getByRole("checkbox").check();
   await window.waitForTimeout(afterActionWait);
 }

package/tests/e2e/utils/data/helpers/attribute.js

@@ -41,7 +41,7 @@ async function setFeatureColorMap(window, menuTestId, colorMap) {
 	await moveMouseOutOfTheWay(window);
 	await window.waitForTimeout(afterActionWait);
 }
-async function applyAttribute(window, menuTestId, { attributeType, attributeName, item = void 0, colorMap = void 0, min = void 0, max = void 0 }) {
+async function applyAttribute(window, menuTestId, { attributeType, attributeName, item, colorMap, min, max }) {
 	if (typeof menuTestId === "string") {
 		await ensureMenuOpen(window, menuTestId);
 		await ensureFeatureVisible(window, menuTestId);
@@ -64,7 +64,7 @@ async function applyAttribute(window, menuTestId, { attributeType, attributeName
 	}).first().click();
 	await window.waitForTimeout(afterActionWait);
 	if (item !== void 0) await setFeatureItem(window, menuTestId, item);
-	if (colorMap) await setFeatureColorMap(window, menuTestId, colorMap);
+	if (colorMap !== void 0 && colorMap !== "") await setFeatureColorMap(window, menuTestId, colorMap);
 	if (min !== void 0) {
 		const input = container.getByTestId("attributeMinInput").first().locator("input");
 		await input.fill(min.toString());
@@ -81,10 +81,10 @@ async function applyAttribute(window, menuTestId, { attributeType, attributeName
 	await window.waitForTimeout(afterActionWait);
 	await moveMouseOutOfTheWay(window);
 }
-function setFeatureAttribute(window, viewerObjectType, feature, attributeType, attributeName, options = {}) {
+async function setFeatureAttribute(window, viewerObjectType, feature, attributeType, attributeName, options = {}) {
 	let menuTestId = `${viewerObjectType}${feature}Menu`;
 	if (viewerObjectType === "model") menuTestId = "modelStyleMenu";
-	return applyAttribute(window, menuTestId, {
+	await applyAttribute(window, menuTestId, {
 		attributeType,
 		attributeName,
 		...options

package/tests/e2e/utils/data/helpers/attribute.ts

@@ -1,3 +1,4 @@
+import type { Locator, Page } from "@playwright/test";
 import {
   SLIDER_PINK,
   clickColorPickerCanvas,
@@ -10,7 +11,7 @@ import {
   moveMouseOutOfTheWay,
 } from "@tests/utils/viewer_interaction";
 
-async function resetMenuScroll(window, scrollTop = 0) {
+async function resetMenuScroll(window: Page, scrollTop = 0): Promise<void> {
   await window.evaluate((top) => {
     const cardTexts = document.querySelectorAll(".v-card-text");
     for (const cardTextElement of cardTexts) {
@@ -19,14 +20,18 @@ async function resetMenuScroll(window, scrollTop = 0) {
   }, scrollTop);
 }
 
-function getMenuContainer(window, menuTestId) {
+function getMenuContainer(window: Page, menuTestId: string | Locator): Locator {
   if (typeof menuTestId === "string") {
     return window.getByTestId(menuTestId);
   }
   return menuTestId;
 }
 
-async function setFeatureItem(window, menuTestId, item) {
+async function setFeatureItem(
+  window: Page,
+  menuTestId: string | Locator,
+  item: number,
+): Promise<void> {
   const container = getMenuContainer(window, menuTestId);
   const itemSelector = container.getByTestId("itemSelector").first();
   await itemSelector.waitFor({ state: "visible" });
@@ -45,7 +50,11 @@ async function setFeatureItem(window, menuTestId, item) {
   await moveMouseOutOfTheWay(window);
 }
 
-async function setFeatureColorMap(window, menuTestId, colorMap) {
+async function setFeatureColorMap(
+  window: Page,
+  menuTestId: string | Locator,
+  colorMap: string,
+): Promise<void> {
   const container = getMenuContainer(window, menuTestId);
   const colorMapPicker = container.getByTestId("colorMapPicker").first();
   await colorMapPicker.waitFor({ state: "visible" });
@@ -80,17 +89,10 @@ interface ApplyAttributeOptions {
 }
 
 async function applyAttribute(
-  window,
-  menuTestId,
-  {
-    attributeType,
-    attributeName,
-    item = undefined,
-    colorMap = undefined,
-    min = undefined,
-    max = undefined,
-  }: ApplyAttributeOptions,
-) {
+  window: Page,
+  menuTestId: string | Locator,
+  { attributeType, attributeName, item, colorMap, min, max }: ApplyAttributeOptions,
+): Promise<void> {
   if (typeof menuTestId === "string") {
     await ensureMenuOpen(window, menuTestId);
     await ensureFeatureVisible(window, menuTestId);
@@ -125,7 +127,7 @@ async function applyAttribute(
     await setFeatureItem(window, menuTestId, item);
   }
 
-  if (colorMap) {
+  if (colorMap !== undefined && colorMap !== "") {
     await setFeatureColorMap(window, menuTestId, colorMap);
   }
 
@@ -146,22 +148,29 @@ async function applyAttribute(
   await moveMouseOutOfTheWay(window);
 }
 
-function setFeatureAttribute(
-  window,
-  viewerObjectType,
-  feature,
-  attributeType,
-  attributeName,
-  options = {},
-) {
+interface FeatureAttributeOptions {
+  item?: number;
+  colorMap?: string;
+  min?: number | string;
+  max?: number | string;
+}
+
+async function setFeatureAttribute(
+  window: Page,
+  viewerObjectType: string,
+  feature: string,
+  attributeType: string,
+  attributeName: string,
+  options: FeatureAttributeOptions = {},
+): Promise<void> {
   let menuTestId = `${viewerObjectType}${feature}Menu`;
   if (viewerObjectType === "model") {
     menuTestId = "modelStyleMenu";
   }
-  return applyAttribute(window, menuTestId, { attributeType, attributeName, ...options });
+  await applyAttribute(window, menuTestId, { attributeType, attributeName, ...options });
 }
 
-async function setQuickColorMap(window, colorMap) {
+async function setQuickColorMap(window: Page, colorMap: string): Promise<void> {
   const colorMapListFilter = window
     .getByTestId("colorMapListFilter")
     .filter({ visible: true })
@@ -182,7 +191,7 @@ async function setQuickColorMap(window, colorMap) {
   await moveMouseOutOfTheWay(window);
 }
 
-async function setFeatureNoDataColor(window, menuTestId) {
+async function setFeatureNoDataColor(window: Page, menuTestId: string | Locator): Promise<void> {
   if (typeof menuTestId === "string") {
     await ensureMenuOpen(window, menuTestId);
   }

package/tests/e2e/utils/data/helpers/color.js

@@ -39,6 +39,7 @@ async function setOpacity(window, menuTestId, percent) {
 	await ensureFeatureVisible(window, menuTestId);
 	const alphaSlider = window.getByTestId(menuTestId).getByTestId("colorPicker").locator(".v-color-picker-preview__alpha, .v-color-picker__alpha").first();
 	const box = await alphaSlider.boundingBox();
+	if (!box) throw new Error("Could not get bounding box of the opacity slider");
 	await alphaSlider.click({
 		force: true,
 		position: {
@@ -54,26 +55,27 @@ async function setColorBlack(window, menuTestId, container = window) {
 	await setColoringStyle(window, menuTestId, "Constant", container);
 	const canvas = container.getByTestId("colorPicker").locator(".v-color-picker-canvas").first();
 	const box = await canvas.boundingBox();
+	if (!box) throw new Error("Could not get bounding box of the color canvas");
 	await canvas.click({ position: {
 		x: COLOR_CANVAS_OFFSET,
 		y: box.height - COLOR_CANVAS_OFFSET
 	} });
 	await window.waitForTimeout(afterActionWait);
 }
-function setFeatureColorBlack(window, viewerObjectType, feature, container = window) {
-	return setColorBlack(window, `${viewerObjectType}${feature}Menu`, container);
+async function setFeatureColorBlack(window, viewerObjectType, feature, container = window) {
+	await setColorBlack(window, `${viewerObjectType}${feature}Menu`, container);
 }
-function setFeatureColor(window, viewerObjectType, feature, container = window) {
-	return setColor(window, `${viewerObjectType}${feature}Menu`, container);
+async function setFeatureColor(window, viewerObjectType, feature, container = window) {
+	await setColor(window, `${viewerObjectType}${feature}Menu`, container);
 }
-function setFeatureColorWithSlider(window, viewerObjectType, feature, container = window) {
-	return setColorWithSlider(window, `${viewerObjectType}${feature}Menu`, container);
+async function setFeatureColorWithSlider(window, viewerObjectType, feature, container = window) {
+	await setColorWithSlider(window, `${viewerObjectType}${feature}Menu`, container);
 }
-function setFeatureColoringStyle(window, viewerObjectType, feature, coloringStyle, container = window) {
-	return setColoringStyle(window, `${viewerObjectType}${feature}Menu`, coloringStyle, container);
+async function setFeatureColoringStyle(window, viewerObjectType, feature, coloringStyle, container = window) {
+	await setColoringStyle(window, `${viewerObjectType}${feature}Menu`, coloringStyle, container);
 }
-function setFeatureOpacity(window, viewerObjectType, feature, percent) {
-	return setOpacity(window, `${viewerObjectType}${feature}Menu`, percent);
+async function setFeatureOpacity(window, viewerObjectType, feature, percent) {
+	await setOpacity(window, `${viewerObjectType}${feature}Menu`, percent);
 }
 //#endregion
 export { setColor, setColorBlack, setColorWithSlider, setColoringStyle, setFeatureColor, setFeatureColorBlack, setFeatureColorWithSlider, setFeatureColoringStyle, setFeatureOpacity, setOpacity };