@bitforgehq/ui 0.3.0 → 0.3.2

package/fesm2022/bitforgehq-ui-testing.mjs

@@ -397,6 +397,639 @@ var BfDesktopToastHarness = class BfDesktopToastHarness extends ComponentHarness
 		await (await this.host()).sendKeys(TestKey.ESCAPE);
 	}
 };
-export { BfDesktopToastHarness, BfDialogHarness, BfMenuButtonHarness, BfMenuHarness, BfMenuItemHarness, BfRadioGroupHarness, BfSegmentedHarness, BfSelectHarness, installBfJsdomShims, provideBfTesting };
+var BfTableHarness = class BfTableHarness extends ComponentHarness {
+	static hostSelector = "bf-table";
+	caption = this.locatorForOptional("caption");
+	headers = this.locatorForAll("thead th[data-bf-column]");
+	rows = this.locatorForAll("tbody tr[data-bf-table-row]");
+	selectAllBox = this.locatorForOptional("thead input[type=\"checkbox\"]");
+	rowBoxes = this.locatorForAll("tbody tr[data-bf-table-row] input[type=\"checkbox\"]");
+	static with(filters = {}) {
+		return new HarnessPredicate(BfTableHarness, filters).addOption("label", filters.label, async (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label));
+	}
+	async getLabel() {
+		return (await (await this.caption())?.text())?.trim() ?? "";
+	}
+	async getRowCount() {
+		return (await this.rows()).length;
+	}
+	async getHeaderLabels() {
+		return Promise.all((await this.headers()).map(async (th) => (await th.text({ exclude: "[data-bf-stacked-label]" })).trim()));
+	}
+	async getCellText(row, column) {
+		const index = await this.columnIndex(column);
+		if (row < 0 || row >= await this.getRowCount()) throw new Error(`BfTableHarness: no row ${row}`);
+		return (await (await this.locatorForAll(`tbody tr[data-bf-table-row]:nth-of-type(${row + 1}) [data-bf-cell]`)())[index]?.text())?.trim() ?? "";
+	}
+	async sortBy(column) {
+		const key = await (await this.headers())[await this.columnIndex(column)]?.getAttribute("data-bf-column");
+		const button = key ? await this.locatorForOptional(`thead th[data-bf-column="${key}"] button`)() : null;
+		if (!button) throw new Error(`BfTableHarness: the column "${column}" is not sortable`);
+		await button.click();
+	}
+	async getSort() {
+		for (const header of await this.headers()) {
+			const direction = await header.getAttribute("aria-sort");
+			const column = await header.getAttribute("data-bf-column");
+			if (column && (direction === "ascending" || direction === "descending")) return {
+				column,
+				direction
+			};
+		}
+		return null;
+	}
+	async selectRow(index) {
+		const box = (await this.rowBoxes())[index];
+		if (!box) throw new Error(`BfTableHarness: no selectable row ${index}`);
+		await this.check(box);
+	}
+	async selectAll() {
+		const box = await this.selectAllBox();
+		if (!box) throw new Error("BfTableHarness: the table is not selectable");
+		await this.check(box);
+	}
+	async getSelectedCount() {
+		return (await Promise.all((await this.rowBoxes()).map((box) => box.getProperty("checked")))).filter(Boolean).length;
+	}
+	async check(box) {
+		if (!await box.getProperty("checked")) await box.click();
+	}
+	async columnIndex(column) {
+		const labels = await this.getHeaderLabels();
+		const index = labels.indexOf(column);
+		if (index === -1) throw new Error(`BfTableHarness: no column "${column}" (columns: ${labels.join(", ")})`);
+		return index;
+	}
+};
+var BfPaginationHarness = class BfPaginationHarness extends ComponentHarness {
+	static hostSelector = "bf-pagination";
+	nav = this.locatorFor("nav");
+	previousButton = this.locatorFor("[data-bf-pagination-previous]");
+	nextButton = this.locatorFor("[data-bf-pagination-next]");
+	pages = this.locatorForAll("[data-bf-pagination-page]");
+	static with(filters = {}) {
+		return new HarnessPredicate(BfPaginationHarness, filters).addOption("label", filters.label, async (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label));
+	}
+	async getLabel() {
+		return await (await this.nav()).getAttribute("aria-label") ?? "";
+	}
+	async getCurrentPage() {
+		return Number(await (await this.nav()).getAttribute("data-bf-page"));
+	}
+	async getPageCount() {
+		return Number(await (await this.nav()).getAttribute("data-bf-page-count"));
+	}
+	async getVisiblePages() {
+		return Promise.all((await this.pages()).map(async (page) => Number((await page.text()).trim())));
+	}
+	async goTo(page) {
+		const [buttons, visible] = await Promise.all([this.pages(), this.getVisiblePages()]);
+		const button = buttons[visible.indexOf(page)];
+		if (!button) {
+			const shown = visible.length > 0 ? visible.join(", ") : "none";
+			throw new Error(`BfPaginationHarness: page ${page} has no button (visible: ${shown})`);
+		}
+		await button.click();
+	}
+	async next() {
+		await this.press(await this.nextButton(), "next");
+	}
+	async previous() {
+		await this.press(await this.previousButton(), "previous");
+	}
+	async isPreviousDisabled() {
+		return await (await this.previousButton()).getAttribute("aria-disabled") === "true";
+	}
+	async isNextDisabled() {
+		return await (await this.nextButton()).getAttribute("aria-disabled") === "true";
+	}
+	async press(button, name) {
+		if (await button.getAttribute("aria-disabled") === "true") throw new Error(`BfPaginationHarness: the ${name} button is disabled`);
+		await button.click();
+	}
+};
+const TAB = ":scope > [data-bf-tab-scroller] > [role=\"tablist\"] > [role=\"tab\"]";
+var BfTabGroupHarness = class BfTabGroupHarness extends ComponentHarness {
+	static hostSelector = "bf-tab-group";
+	list = this.locatorFor(":scope > [data-bf-tab-scroller] > [role=\"tablist\"]");
+	tabs = this.locatorForAll(TAB);
+	tabLabels = this.locatorForAll(`${TAB} > [data-label]`);
+	panel = this.locatorForOptional(":scope > [role=\"tabpanel\"]:not([hidden])");
+	static with(filters = {}) {
+		return new HarnessPredicate(BfTabGroupHarness, filters).addOption("label", filters.label, async (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label));
+	}
+	async getLabel() {
+		return await (await this.list()).getAttribute("aria-label") ?? "";
+	}
+	async getTabLabels() {
+		return Promise.all((await this.tabLabels()).map(async (label) => (await label.text()).trim()));
+	}
+	async getSelectedLabel() {
+		const [tabs, labels] = await Promise.all([this.tabs(), this.getTabLabels()]);
+		for (const [index, tab] of tabs.entries()) if (await tab.getAttribute("aria-selected") === "true") return labels[index] ?? null;
+		return null;
+	}
+	async selectTab(label) {
+		const [tabs, labels] = await Promise.all([this.tabs(), this.getTabLabels()]);
+		const tab = tabs[labels.indexOf(label)];
+		if (!tab) throw new Error(`BfTabGroupHarness: no tab "${label}" (tabs: ${labels.join(", ")})`);
+		if (await tab.matchesSelector(":disabled")) throw new Error(`BfTabGroupHarness: the tab "${label}" is disabled`);
+		await tab.click();
+	}
+	async getPanelText() {
+		return (await (await this.panel())?.text())?.trim() ?? "";
+	}
+};
+var BfSidePanelHarness = class BfSidePanelHarness extends ComponentHarness {
+	static hostSelector = "bf-side-panel";
+	title = this.locatorForOptional("[data-side-panel-header] h2");
+	closeButton = this.locatorFor("[data-side-panel-close] button");
+	static with(filters = {}) {
+		return new HarnessPredicate(BfSidePanelHarness, filters).addOption("label", filters.label, async (harness, label) => HarnessPredicate.stringMatches(harness.getTitle(), label));
+	}
+	async getTitle() {
+		return (await (await this.title())?.text())?.trim() ?? "";
+	}
+	async close() {
+		await (await this.closeButton()).click();
+	}
+	async isOpen() {
+		const id = await (await this.host()).getAttribute("data-bf-side-panel-id");
+		if (!id) return false;
+		return await this.documentRootLocatorFactory().locatorForOptional(`.bf-overlay-panel:not([data-bf-closing]) bf-side-panel[data-bf-side-panel-id="${id}"]`)() !== null;
+	}
+};
+var BfCalendarHarness = class BfCalendarHarness extends ComponentHarness {
+	static hostSelector = "bf-calendar";
+	group = this.locatorFor("[role=\"group\"]");
+	liveTitle = this.locatorFor("[aria-live=\"polite\"]");
+	titleButton = this.locatorForOptional("[data-bf-calendar-title]");
+	previousButton = this.locatorForOptional("[data-bf-calendar-previous]");
+	nextButton = this.locatorForOptional("[data-bf-calendar-next]");
+	selectedDay = this.locatorForOptional("td[data-date][aria-selected=\"true\"]");
+	dayGrid = this.locatorForOptional("table[data-bf-calendar-grid=\"day\"]");
+	static with(filters = {}) {
+		return new HarnessPredicate(BfCalendarHarness, filters).addOption("label", filters.label, async (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label));
+	}
+	async getLabel() {
+		return await (await this.group()).getAttribute("aria-label") ?? "";
+	}
+	async getMonthLabel() {
+		return (await (await this.liveTitle()).text()).trim();
+	}
+	async getSelected() {
+		return await (await this.selectedDay())?.getAttribute("data-date") ?? null;
+	}
+	async nextMonth() {
+		await this.clickNav(await this.nextButton(), "next");
+	}
+	async previousMonth() {
+		await this.clickNav(await this.previousButton(), "previous");
+	}
+	async selectDate(iso) {
+		if (!/^\d{4}-\d{2}-\d{2}$/.test(iso)) throw new Error(`BfCalendarHarness: "${iso}" is not an ISO date (YYYY-MM-DD)`);
+		if (!await this.dayGrid()) throw new Error("BfCalendarHarness: the calendar is not showing its days");
+		let day = await this.locatorForOptional(`td[data-date="${iso}"]`)();
+		if (!day) {
+			await this.jumpTo(iso.slice(0, 7));
+			day = await this.locatorForOptional(`td[data-date="${iso}"]`)();
+		}
+		if (!day) throw new Error(`BfCalendarHarness: no day ${iso}`);
+		if (await day.getAttribute("aria-disabled") === "true") throw new Error(`BfCalendarHarness: the day ${iso} is disabled`);
+		if (await (await this.dayGrid())?.getAttribute("aria-disabled") === "true") throw new Error("BfCalendarHarness: the calendar is disabled");
+		await day.click();
+	}
+	async jumpTo(month) {
+		const title = await this.titleButton();
+		if (!title || await title.getProperty("disabled")) throw new Error("BfCalendarHarness: the calendar is disabled");
+		await title.click();
+		await (await this.locatorFor("[data-bf-calendar-title]")()).click();
+		const year = await this.locatorForOptional(`td[data-year="${Number(month.slice(0, 4))}"]`)();
+		if (!year) throw new Error(`BfCalendarHarness: the year view does not list ${month.slice(0, 4)}`);
+		await year.click();
+		const cell = await this.locatorFor(`td[data-month="${month}"]`)();
+		if (await cell.getAttribute("aria-disabled") === "true") throw new Error(`BfCalendarHarness: the month ${month} is outside min and max`);
+		await cell.click();
+	}
+	async clickNav(button, which) {
+		if (!button) throw new Error("BfCalendarHarness: the calendar is not showing its days");
+		if (await button.getProperty("disabled") || await button.getAttribute("aria-disabled") === "true") throw new Error(`BfCalendarHarness: the ${which} month button is disabled`);
+		await button.click();
+	}
+};
+const FOCUSABLE = "a[href], button:not([disabled]), input:not([disabled]):not([type=\"hidden\"]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex=\"-1\"])";
+var BfTooltipHarness = class BfTooltipHarness extends ComponentHarness {
+	static hostSelector = "[data-bf-tooltip]";
+	inner = this.locatorForOptional(FOCUSABLE);
+	static with(filters = {}) {
+		return new HarnessPredicate(BfTooltipHarness, filters).addOption("label", filters.label, async (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label));
+	}
+	async getLabel() {
+		const control = await this.control();
+		return await control.getAttribute("aria-label") ?? (await control.text()).trim();
+	}
+	async show() {
+		await (await this.control()).focus();
+	}
+	async hide() {
+		await (await this.control()).blur();
+	}
+	async isOpen() {
+		return await this.tooltip() !== null;
+	}
+	async getText() {
+		if (!await this.isOpen()) await this.show();
+		const tooltip = await this.tooltip();
+		if (!tooltip) throw new Error("BfTooltipHarness: the tooltip did not show");
+		return (await tooltip.text()).trim();
+	}
+	async control() {
+		const host = await this.host();
+		return await host.matchesSelector("a[href], button:not([disabled]), input:not([disabled]):not([type=\"hidden\"]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex=\"-1\"])") ? host : await this.inner() ?? host;
+	}
+	async tooltip() {
+		const ids = (await (await this.control()).getAttribute("aria-describedby") ?? "").split(/\s+/).filter(Boolean);
+		const root = this.documentRootLocatorFactory();
+		for (const id of ids) {
+			const found = await root.locatorForOptional(`bf-tooltip[id="${id}"]`)();
+			if (found) return found;
+		}
+		return null;
+	}
+};
+var BfPopoverHarness = class BfPopoverHarness extends ComponentHarness {
+	static hostSelector = "[data-bf-popover-trigger]";
+	inner = this.locatorForOptional(FOCUSABLE);
+	static with(filters = {}) {
+		return new HarnessPredicate(BfPopoverHarness, filters).addOption("label", filters.label, async (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label));
+	}
+	async getLabel() {
+		const control = await this.control();
+		return await control.getAttribute("aria-label") ?? (await control.text()).trim();
+	}
+	async open() {
+		if (!await this.isOpen()) await (await this.control()).click();
+	}
+	async close() {
+		await (await this.panel())?.sendKeys(TestKey.ESCAPE);
+	}
+	async isOpen() {
+		return await (await this.control()).getAttribute("aria-expanded") === "true";
+	}
+	async getPanelText() {
+		await this.open();
+		const panel = await this.panel();
+		if (!panel) throw new Error("BfPopoverHarness: the popover did not open");
+		return (await panel.text()).trim();
+	}
+	async control() {
+		const host = await this.host();
+		return await host.matchesSelector("a[href], button:not([disabled]), input:not([disabled]):not([type=\"hidden\"]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex=\"-1\"])") ? host : await this.inner() ?? host;
+	}
+	async panel() {
+		const id = await (await this.control()).getAttribute("aria-controls");
+		return id ? this.documentRootLocatorFactory().locatorForOptional(`[id="${id}"]`)() : null;
+	}
+};
+var BfComboboxHarness = class BfComboboxHarness extends ComponentHarness {
+	static hostSelector = "bf-combobox, bf-multi-combobox";
+	input = this.locatorFor("input[role=\"combobox\"]");
+	label = this.locatorForOptional("label");
+	chips = this.locatorForAll("[data-chip]");
+	removeButtons = this.locatorForAll("[data-chip] button");
+	static with(filters = {}) {
+		return new HarnessPredicate(BfComboboxHarness, filters).addOption("label", filters.label, async (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label));
+	}
+	async getLabel() {
+		const label = await this.label();
+		if (label) return (await label.text({ exclude: "[aria-hidden=\"true\"]" })).trim();
+		return await (await this.input()).getAttribute("aria-label") ?? "";
+	}
+	async open() {
+		if (!await this.isOpen()) await (await this.input()).click();
+	}
+	async close() {
+		if (await this.isOpen()) await (await this.input()).sendKeys(TestKey.ESCAPE);
+	}
+	async isOpen() {
+		return await (await this.input()).getAttribute("aria-expanded") === "true";
+	}
+	async type(query) {
+		const input = await this.input();
+		await input.focus();
+		await input.clear();
+		if (query) await input.sendKeys(query);
+	}
+	async getOptionLabels() {
+		await this.open();
+		return Promise.all((await this.options()).map(async (o) => (await o.label.text()).trim()));
+	}
+	async selectOption(label) {
+		await this.open();
+		const options = await this.options();
+		const labels = await Promise.all(options.map(async (o) => (await o.label.text()).trim()));
+		const option = options[labels.indexOf(label)];
+		if (!option) throw new Error(`BfComboboxHarness: no option "${label}" (options: ${labels.join(", ")})`);
+		if (await option.element.getAttribute("aria-disabled") === "true") throw new Error(`BfComboboxHarness: the option "${label}" is disabled`);
+		await option.element.click();
+	}
+	async getValueText() {
+		return (await this.input()).getProperty("value");
+	}
+	async getChipLabels() {
+		return Promise.all((await this.chips()).map(async (chip) => this.chipLabel(chip)));
+	}
+	async removeChip(label) {
+		const chips = await this.chips();
+		const labels = await Promise.all(chips.map(async (chip) => this.chipLabel(chip)));
+		const index = labels.indexOf(label);
+		if (index < 0) throw new Error(`BfComboboxHarness: no tag "${label}" (tags: ${labels.join(", ")})`);
+		const button = (await this.removeButtons())[index];
+		if (!button) throw new Error(`BfComboboxHarness: the tag "${label}" cannot be removed`);
+		await button.click();
+	}
+	async isDisabled() {
+		return (await this.input()).getProperty("disabled");
+	}
+	async focus() {
+		await (await this.input()).focus();
+	}
+	async blur() {
+		await (await this.input()).blur();
+	}
+	async chipLabel(chip) {
+		return (await chip.text()).trim();
+	}
+	async options() {
+		const id = await (await this.input()).getAttribute("aria-controls");
+		if (!id) return [];
+		const root = this.documentRootLocatorFactory();
+		const [elements, labels] = await Promise.all([root.locatorForAll(`[id="${id}"] [role="option"]`)(), root.locatorForAll(`[id="${id}"] [role="option"] [data-label]`)()]);
+		return elements.map((element, i) => ({
+			element,
+			label: labels[i] ?? element
+		}));
+	}
+};
+async function fieldLabel(field) {
+	if (field.label) return (await field.label.text({ exclude: "[aria-hidden=\"true\"]" })).trim();
+	return await (field.group ?? field.native)?.getAttribute("aria-label") ?? "";
+}
+async function fieldText(field) {
+	if (field.native) return field.native.getProperty("value");
+	if (!(await Promise.all(field.segments.map(async (segment) => await segment.getAttribute("aria-valuenow") !== null))).some(Boolean) || !field.group) return "";
+	return (await field.group.text()).replace(/\s+/g, " ").trim();
+}
+async function clearField(field) {
+	if (field.native) {
+		await field.native.clear();
+		await field.native.dispatchEvent("change");
+		return;
+	}
+	for (const segment of field.segments) await segment.sendKeys(TestKey.BACKSPACE);
+}
+async function typeField(field, text) {
+	if (field.native) {
+		await field.native.setInputValue(text);
+		await field.native.dispatchEvent("change");
+		return;
+	}
+	await clearField(field);
+	const runs = text.match(/\d+|\p{L}+/gu) ?? [];
+	for (const [index, run] of runs.entries()) {
+		const segment = field.segments[index];
+		if (!segment) throw new Error(`BfDateTimeHarness: "${text}" has more parts than the field`);
+		await segment.focus();
+		await segment.sendKeys(...run.split(""));
+		await segment.blur();
+	}
+}
+async function openPanel(trigger) {
+	if (!trigger) throw new Error("BfDateTimeHarness: the field has no picker");
+	if (await trigger.getAttribute("aria-expanded") !== "true") {
+		if (await trigger.getProperty("disabled")) throw new Error("BfDateTimeHarness: the picker is disabled");
+		await trigger.click();
+	}
+	const id = await trigger.getAttribute("aria-controls");
+	if (!id) throw new Error("BfDateTimeHarness: the picker did not open");
+	return id;
+}
+async function pickPanelDate(root, panelId, iso) {
+	await (await root.locatorFor(BfCalendarHarness.with({ ancestor: `[id="${panelId}"]` }))()).selectDate(iso);
+}
+async function pickPanelTime(root, panelId, time) {
+	const option = await root.locatorForOptional(`[id="${panelId}"] [role="option"][data-time="${time}"]`)();
+	if (!option) throw new Error(`BfDateTimeHarness: the list has no time ${time}`);
+	if (await option.getAttribute("aria-disabled") === "true") throw new Error(`BfDateTimeHarness: the time ${time} is disabled`);
+	await option.click();
+}
+var BfDateInputHarness = class BfDateInputHarness extends ComponentHarness {
+	static hostSelector = "bf-date-input";
+	group = this.locatorForOptional("[role=\"group\"]");
+	nativeInput = this.locatorForOptional("input");
+	segments = this.locatorForAll("[role=\"spinbutton\"]");
+	label = this.locatorForOptional("label");
+	trigger = this.locatorForOptional("button[aria-haspopup=\"dialog\"]");
+	static with(filters = {}) {
+		return new HarnessPredicate(BfDateInputHarness, filters).addOption("label", filters.label, async (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label));
+	}
+	async getLabel() {
+		return fieldLabel(await this.elements());
+	}
+	async getValue() {
+		return fieldText(await this.elements());
+	}
+	async setValue(text) {
+		await typeField(await this.elements(), text);
+	}
+	async clear() {
+		await clearField(await this.elements());
+	}
+	async isInvalid() {
+		return await (await this.nativeInput() ?? (await this.segments())[0])?.getAttribute("aria-invalid") === "true";
+	}
+	async isDisabled() {
+		const native = await this.nativeInput();
+		if (native) return native.getProperty("disabled");
+		return await (await this.group())?.getAttribute("aria-disabled") === "true";
+	}
+	async openPicker() {
+		await openPanel(await this.trigger());
+	}
+	async isPickerOpen() {
+		return await (await this.trigger())?.getAttribute("aria-expanded") === "true";
+	}
+	async pickDate(iso) {
+		const panel = await openPanel(await this.trigger());
+		await pickPanelDate(this.documentRootLocatorFactory(), panel, iso);
+	}
+	async elements() {
+		return {
+			group: await this.group(),
+			native: await this.nativeInput(),
+			segments: await this.segments(),
+			label: await this.label()
+		};
+	}
+};
+var BfTimeInputHarness = class BfTimeInputHarness extends ComponentHarness {
+	static hostSelector = "bf-time-input";
+	group = this.locatorForOptional("[role=\"group\"]");
+	nativeInput = this.locatorForOptional("input");
+	segments = this.locatorForAll("[role=\"spinbutton\"]");
+	label = this.locatorForOptional("label");
+	trigger = this.locatorForOptional("button[aria-haspopup=\"dialog\"]");
+	static with(filters = {}) {
+		return new HarnessPredicate(BfTimeInputHarness, filters).addOption("label", filters.label, async (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label));
+	}
+	async getLabel() {
+		return fieldLabel(await this.elements());
+	}
+	async getValue() {
+		return fieldText(await this.elements());
+	}
+	async setValue(text) {
+		await typeField(await this.elements(), text);
+	}
+	async clear() {
+		await clearField(await this.elements());
+	}
+	async isInvalid() {
+		return await (await this.nativeInput() ?? (await this.segments())[0])?.getAttribute("aria-invalid") === "true";
+	}
+	async isDisabled() {
+		const native = await this.nativeInput();
+		if (native) return native.getProperty("disabled");
+		return await (await this.group())?.getAttribute("aria-disabled") === "true";
+	}
+	async openPicker() {
+		await openPanel(await this.trigger());
+	}
+	async isPickerOpen() {
+		return await (await this.trigger())?.getAttribute("aria-expanded") === "true";
+	}
+	async pickTime(time) {
+		const panel = await openPanel(await this.trigger());
+		await pickPanelTime(this.documentRootLocatorFactory(), panel, time);
+	}
+	async elements() {
+		return {
+			group: await this.group(),
+			native: await this.nativeInput(),
+			segments: await this.segments(),
+			label: await this.label()
+		};
+	}
+};
+var BfDateTimeInputHarness = class BfDateTimeInputHarness extends ComponentHarness {
+	static hostSelector = "bf-datetime-input";
+	group = this.locatorForOptional("[role=\"group\"]");
+	nativeInput = this.locatorForOptional("input");
+	segments = this.locatorForAll("[role=\"spinbutton\"]");
+	label = this.locatorForOptional("label");
+	trigger = this.locatorForOptional("button[aria-haspopup=\"dialog\"]");
+	static with(filters = {}) {
+		return new HarnessPredicate(BfDateTimeInputHarness, filters).addOption("label", filters.label, async (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label));
+	}
+	async getLabel() {
+		return fieldLabel(await this.elements());
+	}
+	async getValue() {
+		return fieldText(await this.elements());
+	}
+	async setValue(text) {
+		await typeField(await this.elements(), text);
+	}
+	async clear() {
+		await clearField(await this.elements());
+	}
+	async isInvalid() {
+		return await (await this.nativeInput() ?? (await this.segments())[0])?.getAttribute("aria-invalid") === "true";
+	}
+	async isDisabled() {
+		const native = await this.nativeInput();
+		if (native) return native.getProperty("disabled");
+		return await (await this.group())?.getAttribute("aria-disabled") === "true";
+	}
+	async openPicker() {
+		await openPanel(await this.trigger());
+	}
+	async isPickerOpen() {
+		return await (await this.trigger())?.getAttribute("aria-expanded") === "true";
+	}
+	async pickDate(iso) {
+		const panel = await openPanel(await this.trigger());
+		await pickPanelDate(this.documentRootLocatorFactory(), panel, iso);
+	}
+	async pickTime(time) {
+		const panel = await openPanel(await this.trigger());
+		await pickPanelTime(this.documentRootLocatorFactory(), panel, time);
+	}
+	async elements() {
+		return {
+			group: await this.group(),
+			native: await this.nativeInput(),
+			segments: await this.segments(),
+			label: await this.label()
+		};
+	}
+};
+const LEGEND_BUTTON = "[data-bf-chart-legend] button";
+var BfChartHarness = class BfChartHarness extends ComponentHarness {
+	static hostSelector = "bf-line-chart, bf-bar-chart, bf-donut-chart";
+	figure = this.locatorFor("figure");
+	legendButtons = this.locatorForAll(LEGEND_BUTTON);
+	dataToggle = this.locatorFor("[data-bf-chart-data-toggle]");
+	headCells = this.locatorForAll("[data-bf-chart-table] thead th");
+	bodyCells = this.locatorForAll("[data-bf-chart-table] tbody th, [data-bf-chart-table] tbody td");
+	static with(filters = {}) {
+		return new HarnessPredicate(BfChartHarness, filters).addOption("label", filters.label, async (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label));
+	}
+	async getLabel() {
+		return await (await this.figure()).getAttribute("aria-label") ?? "";
+	}
+	async getSeriesNames() {
+		return Promise.all((await this.legendButtons()).map(async (button) => (await button.text()).trim()));
+	}
+	async isSeriesShown(name) {
+		return await (await this.legendButton(name)).getAttribute("aria-pressed") === "true";
+	}
+	async toggleSeries(name) {
+		await (await this.legendButton(name)).click();
+	}
+	async showData() {
+		const toggle = await this.dataToggle();
+		if (await toggle.getAttribute("aria-expanded") !== "true") await toggle.click();
+		const [head, cells] = await Promise.all([this.headCells(), this.bodyCells()]);
+		const texts = await Promise.all(cells.map(async (cell) => (await cell.text()).trim()));
+		const columns = Math.max(1, head.length);
+		const rows = [];
+		for (let i = 0; i < texts.length; i += columns) rows.push(texts.slice(i, i + columns));
+		return rows;
+	}
+	async legendButton(name) {
+		const [buttons, names] = await Promise.all([this.legendButtons(), this.getSeriesNames()]);
+		const button = buttons[names.indexOf(name)];
+		if (!button) throw new Error(`BfChartHarness: no series "${name}" (series: ${names.join(", ")})`);
+		return button;
+	}
+};
+var BfSidebarToggleHarness = class BfSidebarToggleHarness extends ComponentHarness {
+	static hostSelector = "bf-sidebar-toggle";
+	button = this.locatorFor("button");
+	static with(filters = {}) {
+		return new HarnessPredicate(BfSidebarToggleHarness, filters).addOption("label", filters.label, async (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label));
+	}
+	async getLabel() {
+		return await (await this.button()).getAttribute("aria-label") ?? "";
+	}
+	async isExpanded() {
+		return await (await this.button()).getAttribute("aria-expanded") === "true";
+	}
+	async toggle() {
+		await (await this.button()).click();
+	}
+};
+export { BfCalendarHarness, BfChartHarness, BfComboboxHarness, BfDateInputHarness, BfDateTimeInputHarness, BfDesktopToastHarness, BfDialogHarness, BfMenuButtonHarness, BfMenuHarness, BfMenuItemHarness, BfPaginationHarness, BfPopoverHarness, BfRadioGroupHarness, BfSegmentedHarness, BfSelectHarness, BfSidePanelHarness, BfSidebarToggleHarness, BfTabGroupHarness, BfTableHarness, BfTimeInputHarness, BfTooltipHarness, installBfJsdomShims, provideBfTesting };
 
 //# sourceMappingURL=bitforgehq-ui-testing.mjs.map