1657 lines
43 KiB
TypeScript
1657 lines
43 KiB
TypeScript
import { Page } from '@playwright/test';
|
|
|
|
export interface WxElement {
|
|
id: string;
|
|
label: string;
|
|
name: string;
|
|
typeName: string;
|
|
screenX: number;
|
|
screenY: number;
|
|
width: number;
|
|
height: number;
|
|
centerX: number;
|
|
centerY: number;
|
|
parentId: string | null;
|
|
visible: boolean;
|
|
enabled: boolean;
|
|
lastUpdated: number;
|
|
}
|
|
|
|
export interface FindOptions {
|
|
visible?: boolean;
|
|
enabled?: boolean;
|
|
exact?: boolean;
|
|
type?: string;
|
|
parent?: string;
|
|
}
|
|
|
|
export interface FindFilter extends FindOptions {
|
|
label?: string;
|
|
name?: string;
|
|
}
|
|
|
|
export interface RegistryStats {
|
|
total: number;
|
|
byType: Record<string, number>;
|
|
}
|
|
|
|
export interface WxRenderedElement {
|
|
id: string;
|
|
parentId: string;
|
|
elementType: 'tool' | 'menuitem' | 'sash' | 'auipart' | 'tab' | 'gridcell' | 'listitem' | 'datecell' | 'treeitem' | 'dataviewitem' | 'proprow' | 'listboxitem' | 'spinbutton' | 'slider' | 'slidertrack' | 'textctrl' | 'combobutton' | 'combotextarea' | 'searchctrl' | 'searchbutton' | 'columnheader' | 'styledtext';
|
|
subType: string;
|
|
label: string;
|
|
tooltip: string;
|
|
screenX: number;
|
|
screenY: number;
|
|
width: number;
|
|
height: number;
|
|
centerX: number;
|
|
centerY: number;
|
|
enabled: boolean;
|
|
index: number;
|
|
lastUpdated: number;
|
|
}
|
|
|
|
export interface RenderedFindOptions {
|
|
enabled?: boolean;
|
|
elementType?: string;
|
|
subType?: string;
|
|
parentId?: string;
|
|
exact?: boolean;
|
|
}
|
|
|
|
export interface WxElementRegistry {
|
|
elements: Map<string, WxElement>;
|
|
version: number;
|
|
register(id: string, info: WxElement): void;
|
|
update(id: string, updates: Partial<WxElement>): void;
|
|
unregister(id: string): void;
|
|
findByLabel(label: string, options?: FindOptions): WxElement[];
|
|
findByName(name: string, options?: FindOptions): WxElement[];
|
|
findByType(typeName: string, options?: FindOptions): WxElement[];
|
|
findAll(filter?: FindFilter): WxElement[];
|
|
getElement(id: string): WxElement | null;
|
|
dump(): void;
|
|
getStats(): RegistryStats;
|
|
// Rendered elements support
|
|
renderedElements?: Map<string, WxRenderedElement>;
|
|
renderedVersion?: number;
|
|
findRenderedByLabel?(label: string, options?: RenderedFindOptions): WxRenderedElement[];
|
|
findRenderedByType?(elementType: string, options?: RenderedFindOptions): WxRenderedElement[];
|
|
findRenderedByParent?(parentId: string, options?: RenderedFindOptions): WxRenderedElement[];
|
|
findAllRendered?(filter?: RenderedFindOptions & { label?: string }): WxRenderedElement[];
|
|
dumpRendered?(): void;
|
|
getRenderedStats?(): RegistryStats;
|
|
}
|
|
|
|
declare global {
|
|
interface Window {
|
|
wxElementRegistry?: WxElementRegistry;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Wait for element registry to be available
|
|
*/
|
|
export async function waitForRegistry(page: Page, timeout = 5000): Promise<boolean> {
|
|
try {
|
|
await page.waitForFunction(
|
|
() => typeof window.wxElementRegistry !== 'undefined',
|
|
{ timeout }
|
|
);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Find element by label text
|
|
*/
|
|
export async function findByLabel(
|
|
page: Page,
|
|
label: string,
|
|
options: FindOptions = {}
|
|
): Promise<WxElement | null> {
|
|
const elements = await page.evaluate(
|
|
([label, opts]: [string, FindOptions]) => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry) return [];
|
|
return registry.findByLabel(label, opts);
|
|
},
|
|
[label, options] as [string, FindOptions]
|
|
);
|
|
return elements.length > 0 ? elements[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Find all elements by label text
|
|
*/
|
|
export async function findAllByLabel(
|
|
page: Page,
|
|
label: string,
|
|
options: FindOptions = {}
|
|
): Promise<WxElement[]> {
|
|
return page.evaluate(
|
|
([label, opts]: [string, FindOptions]) => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry) return [];
|
|
return registry.findByLabel(label, opts);
|
|
},
|
|
[label, options] as [string, FindOptions]
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Find element by name
|
|
*/
|
|
export async function findByName(
|
|
page: Page,
|
|
name: string,
|
|
options: FindOptions = {}
|
|
): Promise<WxElement | null> {
|
|
const elements = await page.evaluate(
|
|
([name, opts]: [string, FindOptions]) => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry) return [];
|
|
return registry.findByName(name, opts);
|
|
},
|
|
[name, options] as [string, FindOptions]
|
|
);
|
|
return elements.length > 0 ? elements[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Find elements by type name (e.g., "wxButton", "wxTextCtrl")
|
|
*/
|
|
export async function findByType(
|
|
page: Page,
|
|
typeName: string,
|
|
options: FindOptions = {}
|
|
): Promise<WxElement[]> {
|
|
return page.evaluate(
|
|
([typeName, opts]: [string, FindOptions]) => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry) return [];
|
|
return registry.findByType(typeName, opts);
|
|
},
|
|
[typeName, options] as [string, FindOptions]
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Find all elements matching filter
|
|
*/
|
|
export async function findAll(
|
|
page: Page,
|
|
filter: FindFilter = {}
|
|
): Promise<WxElement[]> {
|
|
return page.evaluate(
|
|
(filter: FindFilter) => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry) return [];
|
|
return registry.findAll(filter);
|
|
},
|
|
filter
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Click on an element by label
|
|
*/
|
|
export async function clickByLabel(
|
|
page: Page,
|
|
label: string,
|
|
options: FindOptions = {}
|
|
): Promise<boolean> {
|
|
const element = await findByLabel(page, label, options);
|
|
if (!element) {
|
|
console.warn(`Element with label "${label}" not found`);
|
|
return false;
|
|
}
|
|
|
|
await page.mouse.click(element.centerX, element.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Click on an element by name
|
|
*/
|
|
export async function clickByName(
|
|
page: Page,
|
|
name: string,
|
|
options: FindOptions = {}
|
|
): Promise<boolean> {
|
|
const element = await findByName(page, name, options);
|
|
if (!element) {
|
|
console.warn(`Element with name "${name}" not found`);
|
|
return false;
|
|
}
|
|
|
|
await page.mouse.click(element.centerX, element.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get element position for manual clicking (returns screen coords)
|
|
*/
|
|
export async function getElementPosition(
|
|
page: Page,
|
|
labelOrName: string,
|
|
options: FindOptions = {}
|
|
): Promise<{ x: number; y: number } | null> {
|
|
// Try label first, then name
|
|
let element = await findByLabel(page, labelOrName, options);
|
|
if (!element) {
|
|
element = await findByName(page, labelOrName, options);
|
|
}
|
|
if (!element) return null;
|
|
|
|
return { x: element.centerX, y: element.centerY };
|
|
}
|
|
|
|
/**
|
|
* Dump all elements to console (for debugging)
|
|
*/
|
|
export async function dumpElements(page: Page): Promise<void> {
|
|
await page.evaluate(() => {
|
|
const registry = window.wxElementRegistry;
|
|
if (registry) {
|
|
registry.dump();
|
|
} else {
|
|
console.log('[wxElementRegistry] Not initialized');
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get registry statistics
|
|
*/
|
|
export async function getRegistryStats(page: Page): Promise<RegistryStats | null> {
|
|
return page.evaluate(() => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry) return null;
|
|
return registry.getStats();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Wait for an element to appear by label
|
|
*/
|
|
export async function waitForElement(
|
|
page: Page,
|
|
label: string,
|
|
options: FindOptions & { timeout?: number } = {}
|
|
): Promise<WxElement | null> {
|
|
const timeout = options.timeout || 5000;
|
|
const { timeout: _, ...findOptions } = options;
|
|
|
|
try {
|
|
await page.waitForFunction(
|
|
([label, opts]: [string, FindOptions]) => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry) return false;
|
|
const elements = registry.findByLabel(label, opts);
|
|
return elements.length > 0;
|
|
},
|
|
[label, findOptions] as [string, FindOptions],
|
|
{ timeout }
|
|
);
|
|
return findByLabel(page, label, findOptions);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// Rendered Elements (toolbar tools, menu items, splitter sashes, AUI parts)
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find rendered element by label (e.g., toolbar tool "New", menu item "File")
|
|
*/
|
|
export async function findRenderedByLabel(
|
|
page: Page,
|
|
label: string,
|
|
options: RenderedFindOptions = {}
|
|
): Promise<WxRenderedElement | null> {
|
|
const elements = await page.evaluate(
|
|
([label, opts]: [string, RenderedFindOptions]) => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry || !registry.findRenderedByLabel) return [];
|
|
return registry.findRenderedByLabel(label, opts);
|
|
},
|
|
[label, options] as [string, RenderedFindOptions]
|
|
);
|
|
return elements.length > 0 ? elements[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Find all rendered elements by label
|
|
*/
|
|
export async function findAllRenderedByLabel(
|
|
page: Page,
|
|
label: string,
|
|
options: RenderedFindOptions = {}
|
|
): Promise<WxRenderedElement[]> {
|
|
return page.evaluate(
|
|
([label, opts]: [string, RenderedFindOptions]) => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry || !registry.findRenderedByLabel) return [];
|
|
return registry.findRenderedByLabel(label, opts);
|
|
},
|
|
[label, options] as [string, RenderedFindOptions]
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Find all rendered elements of a type (tool, menuitem, sash, auipart)
|
|
*/
|
|
export async function findRenderedByType(
|
|
page: Page,
|
|
elementType: string,
|
|
options: RenderedFindOptions = {}
|
|
): Promise<WxRenderedElement[]> {
|
|
return page.evaluate(
|
|
([type, opts]: [string, RenderedFindOptions]) => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry || !registry.findRenderedByType) return [];
|
|
return registry.findRenderedByType(type, opts);
|
|
},
|
|
[elementType, options] as [string, RenderedFindOptions]
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Find rendered element by tooltip
|
|
*/
|
|
export async function findByTooltip(
|
|
page: Page,
|
|
tooltip: string,
|
|
options: RenderedFindOptions = {}
|
|
): Promise<WxRenderedElement | null> {
|
|
const elements = await page.evaluate(
|
|
([tooltip, opts]: [string, RenderedFindOptions]) => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry || !registry.findAllRendered) return [];
|
|
// Find all rendered elements and filter by tooltip
|
|
const all = registry.findAllRendered(opts);
|
|
return all.filter(e => e.tooltip && e.tooltip.includes(tooltip));
|
|
},
|
|
[tooltip, options] as [string, RenderedFindOptions]
|
|
);
|
|
return elements.length > 0 ? elements[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Click on a rendered element by tooltip
|
|
*/
|
|
export async function clickByTooltip(
|
|
page: Page,
|
|
tooltip: string,
|
|
options: RenderedFindOptions = {}
|
|
): Promise<boolean> {
|
|
const element = await findByTooltip(page, tooltip, options);
|
|
if (!element) {
|
|
console.warn(`Element with tooltip "${tooltip}" not found`);
|
|
return false;
|
|
}
|
|
if (!element.enabled) {
|
|
console.warn(`Element with tooltip "${tooltip}" is disabled`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(element.centerX, element.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Click on a toolbar tool by label or tooltip
|
|
*/
|
|
export async function clickToolbarTool(
|
|
page: Page,
|
|
label: string
|
|
): Promise<boolean> {
|
|
const tool = await findRenderedByLabel(page, label, { elementType: 'tool' });
|
|
if (!tool) {
|
|
console.warn(`Toolbar tool "${label}" not found`);
|
|
return false;
|
|
}
|
|
if (!tool.enabled) {
|
|
console.warn(`Toolbar tool "${label}" is disabled`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(tool.centerX, tool.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Click on a menu bar item by label
|
|
*/
|
|
export async function clickMenuBarItem(
|
|
page: Page,
|
|
label: string
|
|
): Promise<boolean> {
|
|
const menuItem = await findRenderedByLabel(page, label, {
|
|
elementType: 'menuitem',
|
|
subType: 'menubar'
|
|
});
|
|
if (!menuItem) {
|
|
console.warn(`Menu bar item "${label}" not found`);
|
|
return false;
|
|
}
|
|
if (!menuItem.enabled) {
|
|
console.warn(`Menu bar item "${label}" is disabled`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(menuItem.centerX, menuItem.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Click on a popup menu item by label
|
|
*/
|
|
export async function clickMenuItem(
|
|
page: Page,
|
|
label: string
|
|
): Promise<boolean> {
|
|
const menuItem = await findRenderedByLabel(page, label, {
|
|
elementType: 'menuitem'
|
|
});
|
|
if (!menuItem) {
|
|
console.warn(`Menu item "${label}" not found`);
|
|
return false;
|
|
}
|
|
if (!menuItem.enabled) {
|
|
console.warn(`Menu item "${label}" is disabled`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(menuItem.centerX, menuItem.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get splitter sash element
|
|
*/
|
|
export async function getSplitterSash(
|
|
page: Page,
|
|
parentId?: string
|
|
): Promise<WxRenderedElement | null> {
|
|
const options: RenderedFindOptions = {};
|
|
if (parentId) options.parentId = parentId;
|
|
|
|
const sashes = await findRenderedByType(page, 'sash', options);
|
|
return sashes.length > 0 ? sashes[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Click on an AUI pane button (close, pin, maximize)
|
|
*/
|
|
export async function clickAuiButton(
|
|
page: Page,
|
|
buttonType: 'close' | 'pin' | 'maximize',
|
|
paneCaption?: string
|
|
): Promise<boolean> {
|
|
const options: RenderedFindOptions = {
|
|
elementType: 'auipart',
|
|
subType: buttonType
|
|
};
|
|
|
|
let button: WxRenderedElement | null = null;
|
|
|
|
if (paneCaption) {
|
|
// Find the specific pane first, then find the button by parent
|
|
const caption = await findRenderedByLabel(page, paneCaption, {
|
|
elementType: 'auipart',
|
|
subType: 'caption'
|
|
});
|
|
if (caption) {
|
|
// Button index is based on pane index
|
|
const paneIndex = caption.index;
|
|
const buttons = await findRenderedByType(page, 'auipart', { subType: buttonType });
|
|
button = buttons.find(b => Math.floor(b.index / 10) === paneIndex) || null;
|
|
}
|
|
} else {
|
|
// Just find the first button of this type
|
|
const buttons = await findRenderedByType(page, 'auipart', options);
|
|
button = buttons.length > 0 ? buttons[0] : null;
|
|
}
|
|
|
|
if (!button) {
|
|
console.warn(`AUI ${buttonType} button not found`);
|
|
return false;
|
|
}
|
|
|
|
await page.mouse.click(button.centerX, button.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Find an AUI pane content area by panel caption
|
|
*/
|
|
export async function findAuiPaneContent(
|
|
page: Page,
|
|
paneCaption: string
|
|
): Promise<WxRenderedElement | null> {
|
|
const contents = await findRenderedByType(page, 'auipart', { subType: 'content' });
|
|
return contents.find(c => c.label === paneCaption) || null;
|
|
}
|
|
|
|
/**
|
|
* Click on an AUI pane content area by panel caption
|
|
*/
|
|
export async function clickAuiPaneContent(
|
|
page: Page,
|
|
paneCaption: string
|
|
): Promise<boolean> {
|
|
const content = await findAuiPaneContent(page, paneCaption);
|
|
if (!content) {
|
|
console.warn(`AUI pane content "${paneCaption}" not found`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(content.centerX, content.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get all AUI pane content areas
|
|
*/
|
|
export async function findAllAuiPaneContents(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'auipart', { subType: 'content' });
|
|
}
|
|
|
|
/**
|
|
* Click on a rendered element by label (searches all types)
|
|
*/
|
|
export async function clickRenderedByLabel(
|
|
page: Page,
|
|
label: string,
|
|
options: RenderedFindOptions = {}
|
|
): Promise<boolean> {
|
|
const element = await findRenderedByLabel(page, label, options);
|
|
if (!element) {
|
|
console.warn(`Rendered element "${label}" not found`);
|
|
return false;
|
|
}
|
|
if (!element.enabled) {
|
|
console.warn(`Rendered element "${label}" is disabled`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(element.centerX, element.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Dump all rendered elements to console (for debugging)
|
|
*/
|
|
export async function dumpRenderedElements(page: Page): Promise<void> {
|
|
await page.evaluate(() => {
|
|
const registry = window.wxElementRegistry;
|
|
if (registry && registry.dumpRendered) {
|
|
registry.dumpRendered();
|
|
} else {
|
|
console.log('[wxElementRegistry] Rendered elements not available');
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get rendered elements statistics
|
|
*/
|
|
export async function getRenderedStats(page: Page): Promise<RegistryStats | null> {
|
|
return page.evaluate(() => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry || !registry.getRenderedStats) return null;
|
|
return registry.getRenderedStats();
|
|
});
|
|
}
|
|
|
|
// ============================================================================
|
|
// Grid Cell Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a grid cell by row and column
|
|
*/
|
|
export async function findGridCell(
|
|
page: Page,
|
|
row: number,
|
|
col: number
|
|
): Promise<WxRenderedElement | null> {
|
|
const elements = await page.evaluate(
|
|
([row, col]: [number, number]) => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry || !registry.findAllRendered) return [];
|
|
const allCells = registry.findAllRendered({}).filter(
|
|
e => e.elementType === 'gridcell' && e.tooltip === `Row ${row}, Col ${col}`
|
|
);
|
|
return allCells;
|
|
},
|
|
[row, col] as [number, number]
|
|
);
|
|
return elements.length > 0 ? elements[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Find a grid cell by its label/value
|
|
*/
|
|
export async function findGridCellByLabel(
|
|
page: Page,
|
|
label: string
|
|
): Promise<WxRenderedElement | null> {
|
|
return findRenderedByLabel(page, label, { elementType: 'gridcell' });
|
|
}
|
|
|
|
/**
|
|
* Click on a grid cell by row and column
|
|
*/
|
|
export async function clickGridCell(
|
|
page: Page,
|
|
row: number,
|
|
col: number
|
|
): Promise<boolean> {
|
|
const cell = await findGridCell(page, row, col);
|
|
if (!cell) {
|
|
console.warn(`Grid cell at row ${row}, col ${col} not found`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(cell.centerX, cell.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Click on a grid cell by its label/value
|
|
*/
|
|
export async function clickGridCellByLabel(
|
|
page: Page,
|
|
label: string
|
|
): Promise<boolean> {
|
|
const cell = await findGridCellByLabel(page, label);
|
|
if (!cell) {
|
|
console.warn(`Grid cell with label "${label}" not found`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(cell.centerX, cell.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get all grid cells
|
|
*/
|
|
export async function findAllGridCells(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'gridcell');
|
|
}
|
|
|
|
// ============================================================================
|
|
// List Item Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a list item by its label
|
|
*/
|
|
export async function findListItem(
|
|
page: Page,
|
|
label: string
|
|
): Promise<WxRenderedElement | null> {
|
|
return findRenderedByLabel(page, label, { elementType: 'listitem' });
|
|
}
|
|
|
|
/**
|
|
* Find a list item by row index
|
|
*/
|
|
export async function findListItemByIndex(
|
|
page: Page,
|
|
index: number
|
|
): Promise<WxRenderedElement | null> {
|
|
const items = await findRenderedByType(page, 'listitem');
|
|
return items.find(item => item.index === index) || null;
|
|
}
|
|
|
|
/**
|
|
* Click on a list item by label
|
|
*/
|
|
export async function clickListItem(
|
|
page: Page,
|
|
label: string
|
|
): Promise<boolean> {
|
|
const item = await findListItem(page, label);
|
|
if (!item) {
|
|
console.warn(`List item "${label}" not found`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(item.centerX, item.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Click on a list item by row index
|
|
*/
|
|
export async function clickListItemByIndex(
|
|
page: Page,
|
|
index: number
|
|
): Promise<boolean> {
|
|
const item = await findListItemByIndex(page, index);
|
|
if (!item) {
|
|
console.warn(`List item at index ${index} not found`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(item.centerX, item.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get all list items
|
|
*/
|
|
export async function findAllListItems(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'listitem');
|
|
}
|
|
|
|
// ============================================================================
|
|
// Tab Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a tab by its label
|
|
*/
|
|
export async function findTab(
|
|
page: Page,
|
|
label: string
|
|
): Promise<WxRenderedElement | null> {
|
|
return findRenderedByLabel(page, label, { elementType: 'tab' });
|
|
}
|
|
|
|
/**
|
|
* Click on a tab by label
|
|
*/
|
|
export async function clickTab(
|
|
page: Page,
|
|
label: string
|
|
): Promise<boolean> {
|
|
// Clicking a tab too fast (e.g. immediately after a burst of mouse events)
|
|
// can be dropped before the notebook processes the page change. Re-click and
|
|
// verify the selection actually switched, retrying a few times.
|
|
const maxAttempts = 4;
|
|
for (let attempt = 0; attempt < maxAttempts; attempt++) {
|
|
const tab = await findTab(page, label);
|
|
if (!tab) {
|
|
console.warn(`Tab "${label}" not found`);
|
|
return false;
|
|
}
|
|
|
|
// Already selected (e.g. a previous attempt registered late) -> done.
|
|
const selectedBefore = await findSelectedTab(page);
|
|
if (selectedBefore?.label === label) return true;
|
|
|
|
await page.mouse.click(tab.centerX, tab.centerY);
|
|
|
|
// Poll until the registry reports this tab as the selected one.
|
|
const switched = await page
|
|
.waitForFunction(
|
|
(expected) => {
|
|
const registry = (window as any).wxElementRegistry;
|
|
if (!registry || !registry.findAllRendered) return false;
|
|
return registry
|
|
.findAllRendered({ label: undefined })
|
|
.some(
|
|
(e: any) =>
|
|
e.elementType === 'tab' &&
|
|
e.subType === 'selected' &&
|
|
e.label === expected
|
|
);
|
|
},
|
|
label,
|
|
{ timeout: 1000 }
|
|
)
|
|
.then(() => true)
|
|
.catch(() => false);
|
|
|
|
if (switched) return true;
|
|
await page.waitForTimeout(200);
|
|
}
|
|
|
|
console.warn(`Tab "${label}" did not become selected after ${maxAttempts} attempts`);
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Get all tabs
|
|
*/
|
|
export async function findAllTabs(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'tab');
|
|
}
|
|
|
|
/**
|
|
* Get the currently selected tab
|
|
*/
|
|
export async function findSelectedTab(page: Page): Promise<WxRenderedElement | null> {
|
|
const tabs = await page.evaluate(() => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry || !registry.findAllRendered) return [];
|
|
return registry.findAllRendered({ label: undefined }).filter(
|
|
e => e.elementType === 'tab' && e.subType === 'selected'
|
|
);
|
|
});
|
|
return tabs.length > 0 ? tabs[0] : null;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Calendar Date Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a calendar date by day number
|
|
*/
|
|
export async function findCalendarDate(
|
|
page: Page,
|
|
day: number
|
|
): Promise<WxRenderedElement | null> {
|
|
return findRenderedByLabel(page, String(day), { elementType: 'datecell' });
|
|
}
|
|
|
|
/**
|
|
* Click on a calendar date by day number
|
|
*/
|
|
export async function clickCalendarDate(
|
|
page: Page,
|
|
day: number
|
|
): Promise<boolean> {
|
|
const dateCell = await findCalendarDate(page, day);
|
|
if (!dateCell) {
|
|
console.warn(`Calendar date ${day} not found`);
|
|
return false;
|
|
}
|
|
if (!dateCell.enabled) {
|
|
console.warn(`Calendar date ${day} is out of range`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(dateCell.centerX, dateCell.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get all calendar date cells
|
|
*/
|
|
export async function findAllCalendarDates(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'datecell');
|
|
}
|
|
|
|
/**
|
|
* Get the currently selected calendar date
|
|
*/
|
|
export async function findSelectedCalendarDate(page: Page): Promise<WxRenderedElement | null> {
|
|
const dates = await page.evaluate(() => {
|
|
const registry = window.wxElementRegistry;
|
|
if (!registry || !registry.findAllRendered) return [];
|
|
return registry.findAllRendered({ label: undefined }).filter(
|
|
e => e.elementType === 'datecell' && e.subType === 'selected'
|
|
);
|
|
});
|
|
return dates.length > 0 ? dates[0] : null;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Tree Item Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a tree item by its label
|
|
*/
|
|
export async function findTreeItem(
|
|
page: Page,
|
|
label: string
|
|
): Promise<WxRenderedElement | null> {
|
|
return findRenderedByLabel(page, label, { elementType: 'treeitem' });
|
|
}
|
|
|
|
/**
|
|
* Click on a tree item by label
|
|
*/
|
|
export async function clickTreeItem(
|
|
page: Page,
|
|
label: string
|
|
): Promise<boolean> {
|
|
const item = await findTreeItem(page, label);
|
|
if (!item) {
|
|
console.warn(`Tree item "${label}" not found`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(item.centerX, item.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get all tree items
|
|
*/
|
|
export async function findAllTreeItems(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'treeitem');
|
|
}
|
|
|
|
/**
|
|
* Find tree items by state (expanded, collapsed, leaf)
|
|
*/
|
|
export async function findTreeItemsByState(
|
|
page: Page,
|
|
state: 'expanded' | 'collapsed' | 'leaf'
|
|
): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'treeitem', { subType: state });
|
|
}
|
|
|
|
// ============================================================================
|
|
// DataView Item Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a dataview item by its label
|
|
*/
|
|
export async function findDataViewItem(
|
|
page: Page,
|
|
label: string
|
|
): Promise<WxRenderedElement | null> {
|
|
return findRenderedByLabel(page, label, { elementType: 'dataviewitem' });
|
|
}
|
|
|
|
/**
|
|
* Find a dataview item by row index
|
|
*/
|
|
export async function findDataViewItemByIndex(
|
|
page: Page,
|
|
index: number
|
|
): Promise<WxRenderedElement | null> {
|
|
const items = await findRenderedByType(page, 'dataviewitem');
|
|
return items.find(item => item.index === index) || null;
|
|
}
|
|
|
|
/**
|
|
* Click on a dataview item by label
|
|
*/
|
|
export async function clickDataViewItem(
|
|
page: Page,
|
|
label: string
|
|
): Promise<boolean> {
|
|
const item = await findDataViewItem(page, label);
|
|
if (!item) {
|
|
console.warn(`DataView item "${label}" not found`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(item.centerX, item.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Click on a dataview item by row index
|
|
*/
|
|
export async function clickDataViewItemByIndex(
|
|
page: Page,
|
|
index: number
|
|
): Promise<boolean> {
|
|
const item = await findDataViewItemByIndex(page, index);
|
|
if (!item) {
|
|
console.warn(`DataView item at index ${index} not found`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(item.centerX, item.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get all dataview items
|
|
*/
|
|
export async function findAllDataViewItems(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'dataviewitem');
|
|
}
|
|
|
|
// ============================================================================
|
|
// Property Grid Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a property row by its label
|
|
*/
|
|
export async function findPropertyRow(
|
|
page: Page,
|
|
label: string
|
|
): Promise<WxRenderedElement | null> {
|
|
return findRenderedByLabel(page, label, { elementType: 'proprow' });
|
|
}
|
|
|
|
/**
|
|
* Click on a property row by label
|
|
*/
|
|
export async function clickPropertyRow(
|
|
page: Page,
|
|
label: string
|
|
): Promise<boolean> {
|
|
const row = await findPropertyRow(page, label);
|
|
if (!row) {
|
|
console.warn(`Property row "${label}" not found`);
|
|
return false;
|
|
}
|
|
if (!row.enabled) {
|
|
console.warn(`Property row "${label}" is disabled`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(row.centerX, row.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get all property rows
|
|
*/
|
|
export async function findAllPropertyRows(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'proprow');
|
|
}
|
|
|
|
/**
|
|
* Find property rows by type (category, property, selected, disabled)
|
|
*/
|
|
export async function findPropertyRowsByType(
|
|
page: Page,
|
|
type: 'category' | 'property' | 'selected' | 'disabled'
|
|
): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'proprow', { subType: type });
|
|
}
|
|
|
|
// ============================================================================
|
|
// Listbox/Choice Item Helpers (for dropdown lists)
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a listbox item by its label
|
|
*/
|
|
export async function findListboxItem(
|
|
page: Page,
|
|
label: string
|
|
): Promise<WxRenderedElement | null> {
|
|
return findRenderedByLabel(page, label, { elementType: 'listboxitem' });
|
|
}
|
|
|
|
/**
|
|
* Find a listbox item by index
|
|
*/
|
|
export async function findListboxItemByIndex(
|
|
page: Page,
|
|
index: number
|
|
): Promise<WxRenderedElement | null> {
|
|
const items = await findRenderedByType(page, 'listboxitem');
|
|
return items.find(item => item.index === index) || null;
|
|
}
|
|
|
|
/**
|
|
* Click on a listbox item by label (for wxChoice/wxComboBox dropdowns)
|
|
*/
|
|
export async function clickListboxItem(
|
|
page: Page,
|
|
label: string
|
|
): Promise<boolean> {
|
|
const item = await findListboxItem(page, label);
|
|
if (!item) {
|
|
console.warn(`Listbox item "${label}" not found`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(item.centerX, item.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Click on a listbox item by index
|
|
*/
|
|
export async function clickListboxItemByIndex(
|
|
page: Page,
|
|
index: number
|
|
): Promise<boolean> {
|
|
const item = await findListboxItemByIndex(page, index);
|
|
if (!item) {
|
|
console.warn(`Listbox item at index ${index} not found`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(item.centerX, item.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get all listbox items
|
|
*/
|
|
export async function findAllListboxItems(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'listboxitem');
|
|
}
|
|
|
|
// ============================================================================
|
|
// Spin Button Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a spin button arrow by type
|
|
*/
|
|
export async function findSpinButton(
|
|
page: Page,
|
|
arrowType: 'up' | 'down' | 'left' | 'right'
|
|
): Promise<WxRenderedElement | null> {
|
|
const buttons = await findRenderedByType(page, 'spinbutton', { subType: arrowType });
|
|
return buttons.length > 0 ? buttons[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Click the spin button up arrow (or left for horizontal)
|
|
*/
|
|
export async function clickSpinUp(page: Page): Promise<boolean> {
|
|
// Try 'up' first (vertical), then 'left' (horizontal)
|
|
let button = await findSpinButton(page, 'up');
|
|
if (!button) {
|
|
button = await findSpinButton(page, 'left');
|
|
}
|
|
if (!button) {
|
|
console.warn('Spin up/left button not found');
|
|
return false;
|
|
}
|
|
if (!button.enabled) {
|
|
console.warn('Spin up/left button is disabled');
|
|
return false;
|
|
}
|
|
await page.mouse.click(button.centerX, button.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Click the spin button down arrow (or right for horizontal)
|
|
*/
|
|
export async function clickSpinDown(page: Page): Promise<boolean> {
|
|
// Try 'down' first (vertical), then 'right' (horizontal)
|
|
let button = await findSpinButton(page, 'down');
|
|
if (!button) {
|
|
button = await findSpinButton(page, 'right');
|
|
}
|
|
if (!button) {
|
|
console.warn('Spin down/right button not found');
|
|
return false;
|
|
}
|
|
if (!button.enabled) {
|
|
console.warn('Spin down/right button is disabled');
|
|
return false;
|
|
}
|
|
await page.mouse.click(button.centerX, button.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get all spin buttons
|
|
*/
|
|
export async function findAllSpinButtons(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'spinbutton');
|
|
}
|
|
|
|
// ============================================================================
|
|
// Slider Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a slider thumb by name/label
|
|
*/
|
|
export async function findSlider(
|
|
page: Page,
|
|
name?: string
|
|
): Promise<WxRenderedElement | null> {
|
|
if (name) {
|
|
return findRenderedByLabel(page, name, { elementType: 'slider' });
|
|
}
|
|
const sliders = await findRenderedByType(page, 'slider');
|
|
return sliders.length > 0 ? sliders[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Find a slider track for drag operations
|
|
*/
|
|
export async function findSliderTrack(
|
|
page: Page,
|
|
name?: string
|
|
): Promise<WxRenderedElement | null> {
|
|
if (name) {
|
|
return findRenderedByLabel(page, name, { elementType: 'slidertrack' });
|
|
}
|
|
const tracks = await findRenderedByType(page, 'slidertrack');
|
|
return tracks.length > 0 ? tracks[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Click on a slider thumb
|
|
*/
|
|
export async function clickSlider(
|
|
page: Page,
|
|
name?: string
|
|
): Promise<boolean> {
|
|
const slider = await findSlider(page, name);
|
|
if (!slider) {
|
|
console.warn(`Slider${name ? ` "${name}"` : ''} not found`);
|
|
return false;
|
|
}
|
|
if (!slider.enabled) {
|
|
console.warn(`Slider${name ? ` "${name}"` : ''} is disabled`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(slider.centerX, slider.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Drag slider to a position within the track
|
|
* @param position - value between 0 and 1 (0 = min, 1 = max)
|
|
*/
|
|
export async function dragSliderTo(
|
|
page: Page,
|
|
position: number,
|
|
name?: string
|
|
): Promise<boolean> {
|
|
const slider = await findSlider(page, name);
|
|
const track = await findSliderTrack(page, name);
|
|
if (!slider || !track) {
|
|
console.warn(`Slider or track${name ? ` "${name}"` : ''} not found`);
|
|
return false;
|
|
}
|
|
if (!slider.enabled) {
|
|
console.warn(`Slider${name ? ` "${name}"` : ''} is disabled`);
|
|
return false;
|
|
}
|
|
|
|
// Clamp position to [0, 1]
|
|
position = Math.max(0, Math.min(1, position));
|
|
|
|
// Determine if horizontal or vertical based on track dimensions
|
|
const isHorizontal = track.width > track.height;
|
|
|
|
let targetX: number, targetY: number;
|
|
if (isHorizontal) {
|
|
targetX = track.screenX + track.width * position;
|
|
targetY = track.centerY;
|
|
} else {
|
|
targetX = track.centerX;
|
|
// For vertical sliders, 0 is typically at bottom
|
|
targetY = track.screenY + track.height * (1 - position);
|
|
}
|
|
|
|
// Drag from current slider position to target
|
|
await page.mouse.move(slider.centerX, slider.centerY);
|
|
await page.mouse.down();
|
|
await page.mouse.move(targetX, targetY);
|
|
await page.mouse.up();
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get all sliders
|
|
*/
|
|
export async function findAllSliders(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'slider');
|
|
}
|
|
|
|
// ============================================================================
|
|
// Text Control Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a text control by name
|
|
*/
|
|
export async function findTextCtrl(
|
|
page: Page,
|
|
name?: string
|
|
): Promise<WxRenderedElement | null> {
|
|
if (name) {
|
|
return findRenderedByLabel(page, name, { elementType: 'textctrl' });
|
|
}
|
|
const ctrls = await findRenderedByType(page, 'textctrl');
|
|
return ctrls.length > 0 ? ctrls[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Find a singleline text control
|
|
*/
|
|
export async function findSingleLineTextCtrl(
|
|
page: Page,
|
|
name?: string
|
|
): Promise<WxRenderedElement | null> {
|
|
if (name) {
|
|
const ctrl = await findRenderedByLabel(page, name, { elementType: 'textctrl', subType: 'singleline' });
|
|
return ctrl;
|
|
}
|
|
const ctrls = await findRenderedByType(page, 'textctrl', { subType: 'singleline' });
|
|
return ctrls.length > 0 ? ctrls[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Find a multiline text control
|
|
*/
|
|
export async function findMultiLineTextCtrl(
|
|
page: Page,
|
|
name?: string
|
|
): Promise<WxRenderedElement | null> {
|
|
if (name) {
|
|
const ctrl = await findRenderedByLabel(page, name, { elementType: 'textctrl', subType: 'multiline' });
|
|
return ctrl;
|
|
}
|
|
const ctrls = await findRenderedByType(page, 'textctrl', { subType: 'multiline' });
|
|
return ctrls.length > 0 ? ctrls[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Click on a text control to focus it
|
|
*/
|
|
export async function clickTextCtrl(
|
|
page: Page,
|
|
name?: string
|
|
): Promise<boolean> {
|
|
const ctrl = await findTextCtrl(page, name);
|
|
if (!ctrl) {
|
|
console.warn(`TextCtrl${name ? ` "${name}"` : ''} not found`);
|
|
return false;
|
|
}
|
|
if (!ctrl.enabled) {
|
|
console.warn(`TextCtrl${name ? ` "${name}"` : ''} is disabled`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(ctrl.centerX, ctrl.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get all text controls
|
|
*/
|
|
export async function findAllTextCtrls(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'textctrl');
|
|
}
|
|
|
|
// ============================================================================
|
|
// Combo/Choice Button Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a combo/choice dropdown button
|
|
*/
|
|
export async function findComboButton(
|
|
page: Page,
|
|
value?: string
|
|
): Promise<WxRenderedElement | null> {
|
|
if (value) {
|
|
return findRenderedByLabel(page, value, { elementType: 'combobutton' });
|
|
}
|
|
const buttons = await findRenderedByType(page, 'combobutton');
|
|
return buttons.length > 0 ? buttons[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Click on a combo/choice dropdown button to open/close the dropdown
|
|
*/
|
|
export async function clickComboButton(
|
|
page: Page,
|
|
value?: string
|
|
): Promise<boolean> {
|
|
const button = await findComboButton(page, value);
|
|
if (!button) {
|
|
console.warn(`Combo button${value ? ` with value "${value}"` : ''} not found`);
|
|
return false;
|
|
}
|
|
if (!button.enabled) {
|
|
console.warn(`Combo button${value ? ` with value "${value}"` : ''} is disabled`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(button.centerX, button.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Open a combo/choice dropdown (clicks button if closed)
|
|
*/
|
|
export async function openComboDropdown(
|
|
page: Page,
|
|
value?: string
|
|
): Promise<boolean> {
|
|
const button = await findComboButton(page, value);
|
|
if (!button) {
|
|
console.warn(`Combo button${value ? ` with value "${value}"` : ''} not found`);
|
|
return false;
|
|
}
|
|
// Only click if dropdown is closed
|
|
if (button.subType === 'closed') {
|
|
await page.mouse.click(button.centerX, button.centerY);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Select an item from combo/choice dropdown by label
|
|
* Opens the dropdown if needed, then clicks the item
|
|
*/
|
|
export async function selectComboItem(
|
|
page: Page,
|
|
itemLabel: string,
|
|
comboValue?: string
|
|
): Promise<boolean> {
|
|
// Open the dropdown
|
|
const opened = await openComboDropdown(page, comboValue);
|
|
if (!opened) return false;
|
|
|
|
// Wait a bit for dropdown to appear
|
|
await page.waitForTimeout(100);
|
|
|
|
// Click the listbox item
|
|
return clickListboxItem(page, itemLabel);
|
|
}
|
|
|
|
/**
|
|
* Get all combo buttons
|
|
*/
|
|
export async function findAllComboButtons(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'combobutton');
|
|
}
|
|
|
|
// ============================================================================
|
|
// Search Control Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a search control text field
|
|
*/
|
|
export async function findSearchCtrl(
|
|
page: Page,
|
|
hint?: string
|
|
): Promise<WxRenderedElement | null> {
|
|
if (hint) {
|
|
return findRenderedByLabel(page, hint, { elementType: 'searchctrl' });
|
|
}
|
|
const ctrls = await findRenderedByType(page, 'searchctrl');
|
|
return ctrls.length > 0 ? ctrls[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Click on a search control to focus it
|
|
*/
|
|
export async function clickSearchCtrl(
|
|
page: Page,
|
|
hint?: string
|
|
): Promise<boolean> {
|
|
const ctrl = await findSearchCtrl(page, hint);
|
|
if (!ctrl) {
|
|
console.warn(`SearchCtrl${hint ? ` "${hint}"` : ''} not found`);
|
|
return false;
|
|
}
|
|
if (!ctrl.enabled) {
|
|
console.warn(`SearchCtrl${hint ? ` "${hint}"` : ''} is disabled`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(ctrl.centerX, ctrl.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Find the search button in a search control
|
|
*/
|
|
export async function findSearchButton(
|
|
page: Page
|
|
): Promise<WxRenderedElement | null> {
|
|
const buttons = await findRenderedByType(page, 'searchbutton', { subType: 'search' });
|
|
return buttons.length > 0 ? buttons[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Find the cancel button in a search control
|
|
*/
|
|
export async function findSearchCancelButton(
|
|
page: Page
|
|
): Promise<WxRenderedElement | null> {
|
|
const buttons = await findRenderedByType(page, 'searchbutton', { subType: 'cancel' });
|
|
return buttons.length > 0 ? buttons[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Click the search button
|
|
*/
|
|
export async function clickSearchButton(page: Page): Promise<boolean> {
|
|
const button = await findSearchButton(page);
|
|
if (!button) {
|
|
console.warn('Search button not found');
|
|
return false;
|
|
}
|
|
await page.mouse.click(button.centerX, button.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Click the cancel/clear button in a search control
|
|
*/
|
|
export async function clickSearchCancelButton(page: Page): Promise<boolean> {
|
|
const button = await findSearchCancelButton(page);
|
|
if (!button) {
|
|
console.warn('Search cancel button not found');
|
|
return false;
|
|
}
|
|
await page.mouse.click(button.centerX, button.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get all search controls
|
|
*/
|
|
export async function findAllSearchCtrls(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'searchctrl');
|
|
}
|
|
|
|
// ============================================================================
|
|
// Column Header Helpers (for wxDataViewCtrl, wxGrid, etc.)
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a column header by its title
|
|
*/
|
|
export async function findColumnHeader(
|
|
page: Page,
|
|
title: string
|
|
): Promise<WxRenderedElement | null> {
|
|
return findRenderedByLabel(page, title, { elementType: 'columnheader' });
|
|
}
|
|
|
|
/**
|
|
* Find a column header by index
|
|
*/
|
|
export async function findColumnHeaderByIndex(
|
|
page: Page,
|
|
index: number
|
|
): Promise<WxRenderedElement | null> {
|
|
const headers = await findRenderedByType(page, 'columnheader');
|
|
return headers.find(h => h.index === index) || null;
|
|
}
|
|
|
|
/**
|
|
* Click on a column header by title (for sorting)
|
|
*/
|
|
export async function clickColumnHeader(
|
|
page: Page,
|
|
title: string
|
|
): Promise<boolean> {
|
|
const header = await findColumnHeader(page, title);
|
|
if (!header) {
|
|
console.warn(`Column header "${title}" not found`);
|
|
return false;
|
|
}
|
|
if (!header.enabled) {
|
|
console.warn(`Column header "${title}" is disabled`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(header.centerX, header.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Click on a column header by index
|
|
*/
|
|
export async function clickColumnHeaderByIndex(
|
|
page: Page,
|
|
index: number
|
|
): Promise<boolean> {
|
|
const header = await findColumnHeaderByIndex(page, index);
|
|
if (!header) {
|
|
console.warn(`Column header at index ${index} not found`);
|
|
return false;
|
|
}
|
|
if (!header.enabled) {
|
|
console.warn(`Column header at index ${index} is disabled`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(header.centerX, header.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get all column headers
|
|
*/
|
|
export async function findAllColumnHeaders(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'columnheader');
|
|
}
|
|
|
|
/**
|
|
* Find sortable column headers
|
|
*/
|
|
export async function findSortableColumnHeaders(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'columnheader', { subType: 'sortable' });
|
|
}
|
|
|
|
// ============================================================================
|
|
// Styled Text Control (STC) Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Find a styled text control (code editor) by name
|
|
*/
|
|
export async function findStyledTextCtrl(
|
|
page: Page,
|
|
name?: string
|
|
): Promise<WxRenderedElement | null> {
|
|
if (name) {
|
|
return findRenderedByLabel(page, name, { elementType: 'styledtext' });
|
|
}
|
|
const ctrls = await findRenderedByType(page, 'styledtext');
|
|
return ctrls.length > 0 ? ctrls[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Click on a styled text control to focus it
|
|
*/
|
|
export async function clickStyledTextCtrl(
|
|
page: Page,
|
|
name?: string
|
|
): Promise<boolean> {
|
|
const ctrl = await findStyledTextCtrl(page, name);
|
|
if (!ctrl) {
|
|
console.warn(`StyledTextCtrl${name ? ` "${name}"` : ''} not found`);
|
|
return false;
|
|
}
|
|
if (!ctrl.enabled) {
|
|
console.warn(`StyledTextCtrl${name ? ` "${name}"` : ''} is read-only`);
|
|
return false;
|
|
}
|
|
await page.mouse.click(ctrl.centerX, ctrl.centerY);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get all styled text controls
|
|
*/
|
|
export async function findAllStyledTextCtrls(page: Page): Promise<WxRenderedElement[]> {
|
|
return findRenderedByType(page, 'styledtext');
|
|
}
|