@vuu-ui/vuu-playwright-helpers 4.0.0-beta.7 → 4.0.1

package/README.md

@@ -41,8 +41,16 @@ The existing `locateCell` overloads remain available for gradual migration.
 const menu = await table.showContextMenu("ric", 2);
 
 expect(await menu.hasMenuItems()).toBe(true);
-expect(await menu.hasMenuItems(["Copy text", "Filter"])).toBe(true); // exact, in order
-expect(await menu.menuItemLabels()).toEqual(["Copy text", "Filter"]);
+// exact match, in order - a partial list is false
+expect(
+  await menu.hasMenuItems(["Copy text", "Filter", "Sort", "Delete row"]),
+).toBe(true);
+expect(await menu.menuItemLabels()).toEqual([
+  "Copy text",
+  "Filter",
+  "Sort",
+  "Delete row",
+]);
 
 const copy = menu.menuItem("Copy text"); // or by 0 based index, menu.menuItem(0)
 expect(await copy.hasIcon("edit")).toBe(true);
@@ -61,6 +69,46 @@ await menu.press("Enter");
 await menu.close(); // Escape
 ```
 
+To assert that right clicking a cell does not show a context menu, use
+`assertNoContextMenu`. It waits for the page to render after the right click
+before asserting, so it cannot pass before a menu would have appeared.
+
+```ts
+await table.assertNoContextMenu("ccy", 2);
+```
+
 When a key press depends on the focus change made by the previous key, call
 `assertFocusedMenuItem` in between. Keys pressed before the menu has processed a
 focus change may be delivered to the previously focused item.
+
+## PwChart, PwChartDataPoint
+
+`PwChart` wraps a Vuu `Chart` (ECharts, svg renderer). Data points are located by
+series name (the Vuu column name) and 0 based data index, or category (x axis)
+value, mirroring `PwTable.cell(colName, ariaRowIndex)`.
+
+```ts
+const chart = await new PwChart(page).isReady();
+expect(await chart.seriesNames()).toEqual(["price", "volume"]);
+expect(await chart.categories()).toHaveLength(25);
+
+const point = await chart.dataPoint("price", 3); // or chart.dataPoint("price", "2026-04-05")
+expect(point.value).toEqual(103);
+expect(point.isExcluded).toBe(false);
+await point.hover();
+await point.click(); // selects, with a chart selectionModel
+await expect(point.symbol).toHaveAttribute("fill", "purple");
+
+const menu = await chart.showContextMenu("price", 3); // or point.showContextMenu()
+await menu.menuItem("Exclude Item").click();
+await chart.assertNoContextMenu("price", 3); // when no menu is configured
+```
+
+The data point properties (`value`, `x`, `y`, `isExcluded`) are a snapshot, taken
+when the data point is obtained. Mouse actions resolve the position again and wait
+until it is stable, so they work while the chart is resizing. To assert a change to
+the data, obtain the data point again, e.g.
+`await expect.poll(async () => (await chart.dataPoint("price", 3)).isExcluded).toBe(true)`.
+
+The Vuu `Chart` exposes its ECharts instance on the chart canvas element
+(`echartsInstance`), which `PwChart` uses to map data points to pixel positions.

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.0-beta.7",
+  "version": "4.0.1",
   "author": "heswell",
   "license": "Apache-2.0",
   "main": "./src/index.js",
@@ -9,7 +9,7 @@
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "dependencies": {
-    "@vuu-ui/vuu-protocol-types": "4.0.0-beta.7"
+    "@vuu-ui/vuu-protocol-types": "4.0.1"
   },
   "peerDependencies": {
     "@playwright/test": "^1.62.1"

package/src/PwChart.js

@@ -0,0 +1,77 @@
+import { expect } from "@playwright/test";
+import { PwComponent } from "./PwComponent.js";
+import { PwContextMenu } from "./PwContextMenu.js";
+import { PwChartDataPoint } from "./PwChartDataPoint.js";
+class PwChart extends PwComponent {
+    defaultCssSelector = ".vuuChart";
+    get canvas() {
+        return this.locator.locator("[_echarts_instance_]");
+    }
+    async isReady(options) {
+        await super.isReady(options);
+        await expect.poll(()=>this.canvas.evaluate((element)=>(element.echartsInstance?.getOption().series ?? []).some((series)=>series.data.length > 0)), options).toBe(true);
+        return this;
+    }
+    async seriesNames() {
+        await this.isReady();
+        return this.canvas.evaluate((element)=>{
+            const series = element.echartsInstance?.getOption().series ?? [];
+            return Array.from(new Set(series.map(({ name })=>name)));
+        });
+    }
+    async categories() {
+        await this.isReady();
+        return this.canvas.evaluate((element)=>element.echartsInstance?.getOption().xAxis?.[0]?.data ?? []);
+    }
+    async dataPoint(seriesName, dataIndexOrCategory) {
+        await this.isReady();
+        const resolve = ()=>this.resolveDataPoint(seriesName, dataIndexOrCategory);
+        return new PwChartDataPoint(this.page, this.canvas, await resolve(), resolve);
+    }
+    async resolveDataPoint(seriesName, dataIndexOrCategory) {
+        const info = await this.canvas.evaluate((element, [seriesName, dataIndexOrCategory])=>{
+            const chart = element.echartsInstance;
+            if (!chart) return "chart has no echartsInstance";
+            const { series = [], xAxis = [] } = chart.getOption();
+            const categories = xAxis[0]?.data ?? [];
+            const dataIndex = "number" == typeof dataIndexOrCategory ? dataIndexOrCategory : categories.indexOf(dataIndexOrCategory);
+            if (-1 === dataIndex) return `no category "${dataIndexOrCategory}"`;
+            const namedSeries = series.filter(({ name })=>name === seriesName);
+            if (0 === namedSeries.length) return `no series "${seriesName}"`;
+            const valueSeries = namedSeries.find(({ data })=>"number" == typeof data[dataIndex]?.value);
+            if (!valueSeries) return `series "${seriesName}" has no value at data index ${dataIndex}`;
+            const value = valueSeries.data[dataIndex].value;
+            const [x, y] = chart.convertToPixel({
+                seriesId: valueSeries.id
+            }, [
+                dataIndex,
+                value
+            ]);
+            return {
+                seriesName,
+                dataIndex,
+                category: categories[dataIndex],
+                value,
+                isExcluded: valueSeries.id !== seriesName,
+                x,
+                y
+            };
+        }, [
+            seriesName,
+            dataIndexOrCategory
+        ]);
+        if ("string" == typeof info) throw Error(`PwChart, dataPoint, ${info}`);
+        return info;
+    }
+    async showContextMenu(seriesName, dataIndexOrCategory) {
+        const dataPoint = await this.dataPoint(seriesName, dataIndexOrCategory);
+        return dataPoint.showContextMenu();
+    }
+    async assertNoContextMenu(seriesName, dataIndexOrCategory) {
+        const dataPoint = await this.dataPoint(seriesName, dataIndexOrCategory);
+        await PwContextMenu.assertNotOpened(this.page, ()=>dataPoint.click({
+                button: "right"
+            }));
+    }
+}
+export { PwChart };

package/src/PwChartDataPoint.js

@@ -0,0 +1,61 @@
+import { PlaywrightPageObject } from "./PlaywrightPageObject.js";
+import { PwContextMenu } from "./PwContextMenu.js";
+class PwChartDataPoint extends PlaywrightPageObject {
+    canvas;
+    resolve;
+    seriesName;
+    dataIndex;
+    category;
+    value;
+    isExcluded;
+    x;
+    y;
+    constructor(page, canvas, info, resolve){
+        super(page), this.canvas = canvas, this.resolve = resolve;
+        this.seriesName = info.seriesName;
+        this.dataIndex = info.dataIndex;
+        this.category = info.category;
+        this.value = info.value;
+        this.isExcluded = info.isExcluded;
+        this.x = info.x;
+        this.y = info.y;
+    }
+    get symbol() {
+        const position = `,${round(this.x)},${round(this.y)})`;
+        return this.canvas.locator(`svg path[transform$="${position}"]`);
+    }
+    async click(options) {
+        const position = await this.stablePosition();
+        await this.canvas.click({
+            ...options,
+            position
+        });
+    }
+    async hover() {
+        await this.canvas.hover({
+            position: await this.stablePosition()
+        });
+    }
+    showContextMenu() {
+        return PwContextMenu.open(this.page, ()=>this.click({
+                button: "right"
+            }));
+    }
+    async stablePosition() {
+        let { x, y } = await this.resolve();
+        for(let attempt = 0; attempt < MAX_STABLE_ATTEMPTS; attempt++){
+            await nextAnimationFrames(this.page);
+            const current = await this.resolve();
+            if (current.x === x && current.y === y) return {
+                x,
+                y
+            };
+            ({ x, y } = current);
+        }
+        throw Error(`PwChartDataPoint, ${this.seriesName}[${this.dataIndex}] position is not stable`);
+    }
+}
+const MAX_STABLE_ATTEMPTS = 50;
+const round = (value)=>parseFloat(value.toFixed(4));
+const nextAnimationFrames = (page)=>page.evaluate(()=>new Promise((resolve)=>requestAnimationFrame(()=>requestAnimationFrame(()=>resolve()))));
+export { PwChartDataPoint };

package/src/PwColumnPicker.js

@@ -0,0 +1,44 @@
+import { expect } from "@playwright/test";
+import { PwComponent } from "./PwComponent.js";
+import { cssAttributeValue } from "./selector-utils.js";
+class PwColumnPicker extends PwComponent {
+    defaultCssSelector = ".vuuColumnPicker";
+    get selectedOptions() {
+        return this.locator.locator(".vuuItemPicker-selectedList [role='option']");
+    }
+    get availableOptions() {
+        return this.locator.locator(".vuuItemPicker-availableList [role='option']");
+    }
+    selectedColumns() {
+        return this.optionNames(this.selectedOptions);
+    }
+    availableColumns() {
+        return this.optionNames(this.availableOptions);
+    }
+    async addColumn(columnName) {
+        await this.clickAction(this.option(this.availableOptions, columnName));
+    }
+    async removeColumn(columnName) {
+        await this.clickAction(this.option(this.selectedOptions, columnName));
+    }
+    async search(text) {
+        await this.locator.getByRole("search").getByRole("textbox").fill(text);
+    }
+    async assertSelectedColumns(columnNames) {
+        await expect.poll(()=>this.selectedColumns()).toEqual(columnNames);
+    }
+    async assertAvailableColumns(columnNames) {
+        await expect.poll(()=>this.availableColumns()).toEqual(expect.arrayContaining(columnNames));
+    }
+    async clickAction(option) {
+        await option.hover();
+        await option.locator(".vuuItemPickerListItem-action").click();
+    }
+    option(options, columnName) {
+        return options.and(this.page.locator(`[data-name="${cssAttributeValue(columnName)}"]`));
+    }
+    optionNames(options) {
+        return options.evaluateAll((elements)=>elements.map((element)=>element.getAttribute("data-name") ?? ""));
+    }
+}
+export { PwColumnPicker };

package/src/PwContextMenu.js

@@ -1,8 +1,22 @@
 import { expect } from "@playwright/test";
 import { PwComponent } from "./PwComponent.js";
 import { PwMenuItem } from "./PwMenuItem.js";
+import { byId } from "./selector-utils.js";
 class PwContextMenu extends PwComponent {
     defaultCssSelector = '.vuuContextMenuPanel[role="menu"]';
+    static async open(page, openAction) {
+        await openAction();
+        const menu = await new PwContextMenu(page).isReady();
+        const menuId = await menu.locator.getAttribute("id");
+        const contextMenu = menuId ? new PwContextMenu(page, byId(menuId)) : menu;
+        await expect(contextMenu.locator.and(page.locator(":focus-within"))).toHaveCount(1);
+        return contextMenu;
+    }
+    static async assertNotOpened(page, openAction) {
+        await openAction();
+        await page.evaluate(()=>new Promise((resolve)=>requestAnimationFrame(()=>requestAnimationFrame(()=>resolve()))));
+        await new PwContextMenu(page).assertNotAttached();
+    }
     get menuItems() {
         return this.locator.getByRole("menuitem");
     }

package/src/PwTable.js

@@ -2,7 +2,8 @@ import { expect } from "@playwright/test";
 import { PwComponent } from "./PwComponent.js";
 import { PwContextMenu } from "./PwContextMenu.js";
 import { PwTableHeaderCell } from "./PwTableHeaderCell.js";
-import { byDataIcon, byId, cssAttributeValue } from "./selector-utils.js";
+import { byDataIcon, cssAttributeValue } from "./selector-utils.js";
+const SCROLL_TOLERANCE = 1;
 const byAriaRowIndex = (ariaRowIndex)=>`[aria-rowindex="${ariaRowIndex}"]:scope`;
 const xpathStringLiteral = (value)=>{
     if (!value.includes("'")) return `'${value}'`;
@@ -17,6 +18,56 @@ class PwTable extends PwComponent {
     get scrollbarContainer() {
         return this.locator.locator(".vuuTable-scrollbarContainer");
     }
+    scrollPosition() {
+        return this.scrollbarContainer.evaluate(({ scrollLeft, scrollTop })=>({
+                scrollLeft,
+                scrollTop
+            }));
+    }
+    scrollUp(distance) {
+        return this.scroll("vertical", -1, distance);
+    }
+    scrollDown(distance) {
+        return this.scroll("vertical", 1, distance);
+    }
+    scrollLeft(distance) {
+        return this.scroll("horizontal", -1, distance);
+    }
+    scrollRight(distance) {
+        return this.scroll("horizontal", 1, distance);
+    }
+    async scroll(axis, direction, distance) {
+        if ("number" == typeof distance && distance < 0) throw Error("PwTable, scroll, distance must not be negative, use the opposite direction");
+        await this.scrollbarContainer.evaluate((el, { axis, direction, distance })=>{
+            const vertical = "vertical" === axis;
+            const current = vertical ? el.scrollTop : el.scrollLeft;
+            const max = vertical ? el.scrollHeight - el.clientHeight : el.scrollWidth - el.clientWidth;
+            const pos = "start" === distance ? 0 : "end" === distance ? max : current + direction * ("page" === distance ? el.clientHeight : distance);
+            el.scrollTo({
+                [vertical ? "top" : "left"]: Math.min(max, Math.max(0, pos)),
+                behavior: "instant"
+            });
+        }, {
+            axis,
+            direction,
+            distance
+        });
+        await expect.poll(()=>this.isContentScrollSynced(), {
+            message: "PwTable, content container scroll position not synced"
+        }).toBe(true);
+    }
+    isContentScrollSynced() {
+        return this.locator.evaluate((table, tolerance)=>{
+            const scrollbar = table.querySelector(".vuuTable-scrollbarContainer");
+            const content = table.querySelector(".vuuTable-contentContainer");
+            if (!scrollbar || !content) return false;
+            const isSynced = (sourcePos, sourceMax, targetPos, targetMax)=>{
+                const expected = sourceMax > 0 ? sourcePos / sourceMax * targetMax : 0;
+                return Math.abs(targetPos - expected) <= tolerance;
+            };
+            return isSynced(scrollbar.scrollTop, scrollbar.scrollHeight - scrollbar.clientHeight, content.scrollTop, content.scrollHeight - content.clientHeight) && isSynced(scrollbar.scrollLeft, scrollbar.scrollWidth - scrollbar.clientWidth, content.scrollLeft, content.scrollWidth - content.clientWidth);
+        }, SCROLL_TOLERANCE);
+    }
     row(row) {
         return this.locator.locator(`[aria-rowindex="${row}"]`);
     }
@@ -34,11 +85,31 @@ class PwTable extends PwComponent {
     async columnNames() {
         return this.locator.locator(".vuuTableHeaderCell .vuuTableHeaderCell-label").allTextContents();
     }
+    headerColumnNames() {
+        return this.locator.locator(".vuuTableHeaderCell[data-column-name]").evaluateAll((elements)=>elements.map((element)=>element.getAttribute("data-column-name") ?? ""));
+    }
+    async assertColumns(columnNames) {
+        await expect.poll(()=>this.headerColumnNames()).toEqual(columnNames);
+    }
     async rowCount() {
         const ariaRowCount = await this.locator.getByRole("table").getAttribute("aria-rowcount");
         if (null === ariaRowCount) throw Error("PwTable, rowCount, table does not have an aria-rowcount");
         return parseInt(ariaRowCount, 10);
     }
+    get dataLoaded() {
+        return expect.poll(()=>this.rowCount()).toBeGreaterThan(0);
+    }
+    async columnValues(columnName) {
+        const headerCell = this.locator.locator(`xpath=.//*[@role='columnheader' and @data-column-name=${xpathStringLiteral(columnName)}]`).first();
+        const ariaColIndex = await headerCell.getAttribute("aria-colindex");
+        if (null === ariaColIndex) throw Error(`PwTable, columnValues, column "${columnName}" does not have an aria-colindex`);
+        const cells = this.locator.locator(`[role="row"] > [role="cell"][aria-colindex="${ariaColIndex}"]`);
+        const values = await cells.evaluateAll((elements)=>elements.map((cell)=>({
+                    rowIndex: Number(cell.parentElement?.getAttribute("aria-rowindex")),
+                    text: cell.textContent ?? ""
+                })));
+        return values.sort((v1, v2)=>v1.rowIndex - v2.rowIndex).map(({ text })=>text);
+    }
     async cellIcon(columnName, ariaRowIndex, iconName) {
         const cell = await this.cell(columnName, ariaRowIndex);
         return cell.locator(byDataIcon(iconName));
@@ -53,12 +124,16 @@ class PwTable extends PwComponent {
     }
     async showContextMenu(columnName, ariaRowIndex) {
         const cell = await this.cell(columnName, ariaRowIndex);
-        await cell.click({
-            button: "right"
-        });
-        const menu = await new PwContextMenu(this.page).isReady();
-        const menuId = await menu.locator.getAttribute("id");
-        return menuId ? new PwContextMenu(this.page, byId(menuId)) : menu;
+        return PwContextMenu.open(this.page, ()=>cell.click({
+                button: "right"
+            }));
+    }
+    async assertNoContextMenu(columnName, ariaRowIndex) {
+        const cell = await this.cell(columnName, ariaRowIndex);
+        await PwContextMenu.assertNotOpened(this.page, ()=>cell.click({
+                button: "right"
+            }));
+        await expect(cell).not.toContainClass("ContextOpen");
     }
     locateCell(rowOrText, column) {
         if ("number" == typeof rowOrText && "number" == typeof column) return this.locator.locator(`[aria-rowindex="${rowOrText}"] > [aria-colindex="${column}"]`);

package/src/PwTableFooter.js

@@ -0,0 +1,16 @@
+import { PwColumnPicker } from "./PwColumnPicker.js";
+import { PwComponent } from "./PwComponent.js";
+class PwTableFooter extends PwComponent {
+    defaultCssSelector = ".vuuTableFooter";
+    action(name) {
+        return this.locator.getByRole("button", {
+            name,
+            exact: true
+        });
+    }
+    async showColumnPicker(name = "Show column picker") {
+        await this.action(name).click();
+        return new PwColumnPicker(this.page).isReady();
+    }
+}
+export { PwTableFooter };

package/src/PwTableHeaderCell.js

@@ -1,5 +1,6 @@
 import { expect } from "@playwright/test";
 import { PwComponent } from "./PwComponent.js";
+import { PwContextMenu } from "./PwContextMenu.js";
 class PwTableHeaderCell extends PwComponent {
     defaultCssSelector = ".vuuTableHeaderCell";
     constructor(page, target){
@@ -11,5 +12,12 @@ class PwTableHeaderCell extends PwComponent {
     async assertSelected() {
         await expect(this.locator).toContainClass("vuuTableHeaderCell-selected");
     }
+    async showColumnMenu() {
+        await this.locator.getByRole("button", {
+            name: "Open Column Menu",
+            exact: true
+        }).click();
+        return new PwContextMenu(this.page, this.page.locator(".saltMenuPanel[role='menu']")).isReady();
+    }
 }
 export { PwTableHeaderCell };

package/src/index.js

@@ -1,6 +1,10 @@
 export { PlaywrightPageObject } from "./PlaywrightPageObject.js";
+export { PwChart } from "./PwChart.js";
+export { PwChartDataPoint } from "./PwChartDataPoint.js";
+export { PwColumnPicker } from "./PwColumnPicker.js";
 export { PwComponent } from "./PwComponent.js";
 export { PwContextMenu } from "./PwContextMenu.js";
 export { PwMenuItem } from "./PwMenuItem.js";
 export { PwTable } from "./PwTable.js";
+export { PwTableFooter } from "./PwTableFooter.js";
 export { PwTableHeaderCell } from "./PwTableHeaderCell.js";

package/types/PwChart.d.ts

@@ -0,0 +1,124 @@
+import { type Locator } from "@playwright/test";
+import { PwComponent } from "./PwComponent";
+import { PwContextMenu } from "./PwContextMenu";
+import { PwChartDataPoint } from "./PwChartDataPoint";
+/**
+ * A Vuu Chart (VuuChart, an ECharts line chart). Data points are identified by
+ * series name, which is the Vuu column name, and 0 based data index, which is
+ * also the index of the category on the x axis.
+ *
+ * The chart must use the svg renderer for symbol locators (PwChartDataPoint.symbol).
+ *
+ * @example
+ * test("chart renders price and volume", async ({ mount, page }) => {
+ *   await mount("Chart/LineChart/SimpleLineChart");
+ *   const chart = await new PwChart(page).isReady();
+ *   expect(await chart.seriesNames()).toEqual(["price", "volume"]);
+ *   const point = await chart.dataPoint("price", 0);
+ *   expect(point.value).toEqual(100);
+ * });
+ */
+export declare class PwChart extends PwComponent {
+    protected readonly defaultCssSelector = ".vuuChart";
+    /**
+     * Locator for the element that renders the chart. This element receives
+     * mouse events and holds the ECharts instance.
+     *
+     * @example
+     * test("chart renders svg", async ({ page }) => {
+     *   const chart = new PwChart(page);
+     *   await expect(chart.canvas.locator("svg")).toBeVisible();
+     * });
+     */
+    get canvas(): Locator;
+    /**
+     * Wait until the chart is visible and has rendered series data. Resolves
+     * with the chart, so it can be chained.
+     *
+     * @example
+     * test("chart is ready", async ({ mount, page }) => {
+     *   await mount("Chart/LineChart/SimpleLineChart");
+     *   const chart = await new PwChart(page).isReady();
+     *   expect(await chart.categories()).toHaveLength(25);
+     * });
+     */
+    isReady(options?: {
+        timeout?: number;
+    }): Promise<this>;
+    /**
+     * The names of the rendered series, in render order. These are the Vuu
+     * column names of the series columns.
+     *
+     * @example
+     * test("price only", async ({ page }) => {
+     *   await page.getByRole("button", { name: "Price Only" }).click();
+     *   const chart = await new PwChart(page).isReady();
+     *   await expect.poll(() => chart.seriesNames()).toEqual(["price"]);
+     * });
+     */
+    seriesNames(): Promise<string[]>;
+    /**
+     * The category (x axis) values, in order.
+     *
+     * @example
+     * test("first category", async ({ page }) => {
+     *   const chart = await new PwChart(page).isReady();
+     *   expect((await chart.categories())[0]).toEqual("2026-04-02");
+     * });
+     */
+    categories(): Promise<string[]>;
+    /**
+     * Locate a data point by series name and 0 based data index, or by category
+     * (x axis) value. Waits for the chart to be ready. Rejects if the series or
+     * data point does not exist, or the data point has no value.
+     *
+     * @param seriesName the series (Vuu column) name
+     * @param dataIndexOrCategory 0 based data index, or category value
+     *
+     * @example
+     * test("locate data points", async ({ page }) => {
+     *   const chart = new PwChart(page);
+     *   const byIndex = await chart.dataPoint("price", 3);
+     *   const byCategory = await chart.dataPoint("price", "2026-04-05");
+     *   expect(byIndex.value).toEqual(byCategory.value);
+     * });
+     */
+    dataPoint(seriesName: string, dataIndexOrCategory: number | string): Promise<PwChartDataPoint>;
+    private resolveDataPoint;
+    /**
+     * Right click a data point to invoke the context menu. Resolves once the
+     * menu is visible and has focus. Waits until the test timeout if no context
+     * menu is shown, use assertNoContextMenu to test for that.
+     *
+     * @param seriesName the series (Vuu column) name
+     * @param dataIndexOrCategory 0 based data index, or category value
+     *
+     * @example
+     * test("exclude data point", async ({ mount, page }) => {
+     *   await mount("Chart/LineChart/DataExclusions");
+     *   const chart = new PwChart(page);
+     *   const menu = await chart.showContextMenu("price", 3);
+     *   expect(await menu.hasMenuItems(["Exclude Item"])).toBe(true);
+     *   await menu.menuItem("Exclude Item").click();
+     *   await expect
+     *     .poll(async () => (await chart.dataPoint("price", 3)).isExcluded)
+     *     .toBe(true);
+     * });
+     */
+    showContextMenu(seriesName: string, dataIndexOrCategory: number | string): Promise<PwContextMenu>;
+    /**
+     * Right click a data point and assert that no context menu is shown. Waits
+     * for the page to render after the right click before asserting, so it
+     * cannot pass before a menu would have appeared.
+     *
+     * @param seriesName the series (Vuu column) name
+     * @param dataIndexOrCategory 0 based data index, or category value
+     *
+     * @example
+     * test("no context menu in view mode", async ({ mount, page }) => {
+     *   await mount("Chart/LineChart/EditableChart");
+     *   await new PwChart(page).assertNoContextMenu("price", 3);
+     * });
+     */
+    assertNoContextMenu(seriesName: string, dataIndexOrCategory: number | string): Promise<void>;
+}