@dev-blinq/bvt-playwright-js 1.0.0-dev.4.latest.138.1 → 1.0.0-dev.4.latest.149.1

package/index.d.mts

@@ -276,6 +276,14 @@ declare const elementAssertionSchema: z.ZodDiscriminatedUnion<[
 	z.ZodObject<{
 		type: z.ZodLiteral<"toHaveProperty">;
 		name: z.ZodString;
+		operator: z.ZodOptional<z.ZodEnum<{
+			equals: "equals";
+			notEquals: "notEquals";
+			contains: "contains";
+			lessThan: "lessThan";
+			greaterThan: "greaterThan";
+			exists: "exists";
+		}>>;
 		value: z.ZodOptional<z.ZodDiscriminatedUnion<[
 			z.ZodObject<{
 				type: z.ZodLiteral<"string">;
@@ -1336,6 +1344,7 @@ declare const CommandSchema: z.ZodDiscriminatedUnion<[
 		], "type">;
 		target: z.ZodObject<{
 			name: z.ZodString;
+			isElementHidden: z.ZodOptional<z.ZodBoolean>;
 			uniqueSelectors: z.ZodArray<z.ZodDiscriminatedUnion<[
 				z.ZodObject<{
 					type: z.ZodLiteral<"pw.selectorString">;
@@ -2011,6 +2020,14 @@ declare const CommandSchema: z.ZodDiscriminatedUnion<[
 			z.ZodObject<{
 				type: z.ZodLiteral<"toHaveProperty">;
 				name: z.ZodString;
+				operator: z.ZodOptional<z.ZodEnum<{
+					equals: "equals";
+					notEquals: "notEquals";
+					contains: "contains";
+					lessThan: "lessThan";
+					greaterThan: "greaterThan";
+					exists: "exists";
+				}>>;
 				value: z.ZodOptional<z.ZodDiscriminatedUnion<[
 					z.ZodObject<{
 						type: z.ZodLiteral<"string">;
@@ -2096,6 +2113,7 @@ declare const CommandSchema: z.ZodDiscriminatedUnion<[
 		], "type">;
 		target: z.ZodObject<{
 			name: z.ZodString;
+			isElementHidden: z.ZodOptional<z.ZodBoolean>;
 			uniqueSelectors: z.ZodArray<z.ZodDiscriminatedUnion<[
 				z.ZodObject<{
 					type: z.ZodLiteral<"pw.selectorString">;
@@ -2740,6 +2758,7 @@ declare const CommandSchema: z.ZodDiscriminatedUnion<[
 		], "type">;
 		target: z.ZodObject<{
 			name: z.ZodString;
+			isElementHidden: z.ZodOptional<z.ZodBoolean>;
 			uniqueSelectors: z.ZodArray<z.ZodDiscriminatedUnion<[
 				z.ZodObject<{
 					type: z.ZodLiteral<"pw.selectorString">;
@@ -4335,6 +4354,7 @@ declare const StepDefinitionSchema: z.ZodObject<{
 			], "type">;
 			target: z.ZodObject<{
 				name: z.ZodString;
+				isElementHidden: z.ZodOptional<z.ZodBoolean>;
 				uniqueSelectors: z.ZodArray<z.ZodDiscriminatedUnion<[
 					z.ZodObject<{
 						type: z.ZodLiteral<"pw.selectorString">;
@@ -5010,6 +5030,14 @@ declare const StepDefinitionSchema: z.ZodObject<{
 				z.ZodObject<{
 					type: z.ZodLiteral<"toHaveProperty">;
 					name: z.ZodString;
+					operator: z.ZodOptional<z.ZodEnum<{
+						equals: "equals";
+						notEquals: "notEquals";
+						contains: "contains";
+						lessThan: "lessThan";
+						greaterThan: "greaterThan";
+						exists: "exists";
+					}>>;
 					value: z.ZodOptional<z.ZodDiscriminatedUnion<[
 						z.ZodObject<{
 							type: z.ZodLiteral<"string">;
@@ -5095,6 +5123,7 @@ declare const StepDefinitionSchema: z.ZodObject<{
 			], "type">;
 			target: z.ZodObject<{
 				name: z.ZodString;
+				isElementHidden: z.ZodOptional<z.ZodBoolean>;
 				uniqueSelectors: z.ZodArray<z.ZodDiscriminatedUnion<[
 					z.ZodObject<{
 						type: z.ZodLiteral<"pw.selectorString">;
@@ -5739,6 +5768,7 @@ declare const StepDefinitionSchema: z.ZodObject<{
 			], "type">;
 			target: z.ZodObject<{
 				name: z.ZodString;
+				isElementHidden: z.ZodOptional<z.ZodBoolean>;
 				uniqueSelectors: z.ZodArray<z.ZodDiscriminatedUnion<[
 					z.ZodObject<{
 						type: z.ZodLiteral<"pw.selectorString">;
@@ -8793,6 +8823,9 @@ type PWSelectorDetails = {
 	score: number;
 	elements?: Element[];
 };
+type SelectorGenerationOptions = Partial<InternalOptions> & {
+	visibleOnly?: boolean;
+};
 declare class SelectorGenerator {
 	private injectedScript;
 	private _pw;
@@ -8805,7 +8838,7 @@ declare class SelectorGenerator {
 	private pushCandidate;
 	getMatchingElements(selector: string, options?: {
 		visibleOnly?: boolean;
-		root?: Element;
+		root?: Element | Document;
 		prefix?: string;
 	}): Element[];
 	private addNearestTextToSelectors;
@@ -8813,13 +8846,14 @@ declare class SelectorGenerator {
 	buildPWNoTextCandidates(element: Element, options?: InternalOptions): PWSelectorDetails[];
 	computeUnique(element: Element, locatorGenerator: (element: Element, options?: InternalOptions & {
 		isTargetNode: boolean;
-	}) => PWSelectorDetails[], strategy: "text" | "css", options?: InternalOptions): Generator<UniqueSelector>;
+	}) => PWSelectorDetails[], strategy: "text" | "css", options?: SelectorGenerationOptions): Generator<UniqueSelector>;
 	computeUnique2(element: Element, locatorGenerator: (element: Element, options?: InternalOptions & {
 		isTargetNode: boolean;
-	}) => PWSelectorDetails[], strategy: "text" | "css", options?: InternalOptions): Generator<UniqueSelector>;
-	getUniquePWSelectors(element: Element, options?: InternalOptions): Generator<UniqueSelector, undefined, unknown>;
+	}) => PWSelectorDetails[], strategy: "text" | "css", options?: SelectorGenerationOptions): Generator<UniqueSelector>;
+	getUniquePWSelectors(element: Element, options?: SelectorGenerationOptions): Generator<UniqueSelector, undefined, unknown>;
 	getCSSChainSelector(element: Element, options: {
 		root?: Element | Document;
+		visibleOnly?: boolean;
 	}): string;
 	getUniqueSelectors(element: Element, options?: InternalOptions & {
 		timeout?: number;
@@ -8849,6 +8883,7 @@ type ElementActionEvent = {
 			bvtId: string;
 			details: ElementDetails;
 			uniqueSelectors: UniqueSelector[];
+			isElementHidden?: boolean;
 		};
 		statistics: {
 			handleEventDurationMs: string;
@@ -9099,6 +9134,9 @@ type UnboxedTuple<T extends unknown[]> = {
 	[K in keyof T]: Unboxed<T[K]>;
 };
 type LocatorScope = Frame | FrameLocator;
+type LocatorVisibilityOptions = {
+	isElementHidden?: boolean;
+};
 type GlobalThis = {
 	__bvt: {
 		BrowserObserver: typeof BrowserObserver;
@@ -9349,7 +9387,7 @@ declare class Tester {
 	isFrameObject(frameScope: LocatorScope): frameScope is Frame;
 	getFrameObjectFromFrameScope(frameScope: FrameLocator | Frame): Promise<Frame>;
 	getFrame(scope: Page, frameElementDescriptors: ElementCommand["target"]["frames"]): Promise<LocatorScope>;
-	getLocator(scope: LocatorScope, uniqueSelector: UniqueSelector): {
+	getLocator(scope: LocatorScope, uniqueSelector: UniqueSelector, options?: LocatorVisibilityOptions): {
 		target: Locator;
 	};
 	executeElementAction(locator: Locator, action: ElementAction): Promise<void>;

package/index.mjs

@@ -5162,6 +5162,17 @@ const primitiveOrRegex = discriminatedUnion("type", [
 	}).strict()
 ]);
 
+//#endregion
+//#region ../../core/schemas/src/assertions/assertion-operators.ts
+const ASSERTION_OPERATORS = [
+	"equals",
+	"notEquals",
+	"contains",
+	"lessThan",
+	"greaterThan",
+	"exists"
+];
+
 //#endregion
 //#region ../../core/schemas/src/api/api.schema.ts
 const numberAssertion = object({
@@ -5393,6 +5404,7 @@ const elementAssertionSchema = discriminatedUnion("type", [
 	object({
 		type: literal$1("toHaveProperty"),
 		name: string(),
+		operator: _enum(ASSERTION_OPERATORS).optional(),
 		value: primitiveOrRegex.optional(),
 		options: object({ timeout: number().optional() }).optional()
 	}),
@@ -6550,6 +6562,7 @@ const RichElementTargetDetailsSchema = object({
 }).passthrough();
 const elementTargetSchema = object({
 	name: string(),
+	isElementHidden: boolean().optional(),
 	uniqueSelectors: array(UniqueSelectorSchema),
 	frames: array(object({
 		name: string(),
@@ -6918,6 +6931,23 @@ const ProjectBrowserLaunchConfigurationSchema = object({
 }).strict();
 const ProjectGitCodegenFormats = ["playwright", "gherkin"];
 const ProjectGitCodegenFormatSchema = _enum(ProjectGitCodegenFormats).default("playwright");
+/**
+* Personalisation inputs for the analytics dashboard.
+*
+* These values drive the "Budget Saved", "Time Saved", and
+* "AI Work Time Distribution" widgets. All hours are in human-hours
+* (the unit the modal collects). The defaults match the legacy
+* Metabase queries' `$ifNull` fallbacks — projects that never
+* customise these still get sensible numbers on day one.
+*/
+const DashboardPersonalizationSchema = object({
+	hourlyRateForTestEngineer: number().nonnegative().default(50),
+	avgTimeToAutomateScenario: number().nonnegative().default(4),
+	avgTimeToAutomateScenarioUsingBlinqIO: number().nonnegative().default(.25),
+	avgTimeToMaintainScenario: number().nonnegative().default(2),
+	avgTimeToAnalyzeFailedScenario: number().nonnegative().default(2)
+}).strict();
+const DEFAULT_DASHBOARD_PERSONALIZATION = DashboardPersonalizationSchema.parse({});
 const ProjectSettingsSchema = object({
 	_id: EntityIdSchema,
 	projectId: EntityIdSchema,
@@ -6928,11 +6958,13 @@ const ProjectSettingsSchema = object({
 			width: 1280,
 			height: 900
 		} }
-	})
+	}),
+	dashboardPersonalization: DashboardPersonalizationSchema.default(DEFAULT_DASHBOARD_PERSONALIZATION)
 }).strict();
 const ProjectSettingsUpdatableFieldsSchema = ProjectSettingsSchema.omit({
 	_id: true,
-	projectId: true
+	projectId: true,
+	dashboardPersonalization: true
 });
 const DEFAULT_PROJECT_SETTINGS = ProjectSettingsUpdatableFieldsSchema.parse({});
 const GetProjectSettingsInputSchema = object({ projectId: EntityIdSchema }).strict();
@@ -27257,7 +27289,7 @@ var Tester = class {
 		if (!frameElementDescriptors || frameElementDescriptors.length === 0) return scope.mainFrame();
 		let currentFrame = scope.mainFrame();
 		for (const frameDescriptor of frameElementDescriptors) for (const selectorInfo of frameDescriptor.uniqueSelectors) {
-			const { target } = this.getLocator(currentFrame, selectorInfo);
+			const { target } = this.getLocator(currentFrame, selectorInfo, { isElementHidden: false });
 			try {
 				if (!await target.elementHandle()) throw new Error(`Could not find element for frame selector: ${JSON.stringify(selectorInfo)}`);
 				const selector = target._selector;
@@ -27269,9 +27301,14 @@ var Tester = class {
 		}
 		return currentFrame;
 	}
-	getLocator(scope, uniqueSelector) {
+	getLocator(scope, uniqueSelector, options) {
 		switch (uniqueSelector.type) {
-			case "pw.selectorString": return { target: scope.locator(uniqueSelector.selectorString + ` >> visible=true`) };
+			case "pw.selectorString": {
+				const visibleSuffix = options?.isElementHidden === true ? "" : ` >> visible=true`;
+				const finalSelector = uniqueSelector.selectorString + visibleSuffix;
+				this.obs.logger.info(`getLocator(pw.selectorString): isElementHidden=${options?.isElementHidden}, visibleAppended=${visibleSuffix !== ""}, finalSelector=${finalSelector}`);
+				return { target: scope.locator(finalSelector) };
+			}
 			case "bvt.selectorObject": throw new Error(`Selector type "bvt.selectorObject" is not yet supported in getLocator`);
 			default:
 				const _exhaustiveCheck = uniqueSelector;
@@ -27390,15 +27427,82 @@ var Tester = class {
 				else await asserter.toHaveAttribute(assertion.name, value, assertion.options);
 				break;
 			}
-			case "toHaveProperty":
-				this.obs.logger.info(`Checking property "${assertion.name}"...`);
-				if (assertion.value === void 0) await asserter.toHaveJSProperty(assertion.name, assertion.options);
-				else {
-					let value = getValueFromPrimitiveOrRegex(assertion.value);
-					this.obs.logger.info(`Expected property value: "${value}" (timeout: ${assertion.options?.timeout ?? "default"}ms)`);
-					await asserter.toHaveJSProperty(assertion.name, value, assertion.options);
+			case "toHaveProperty": {
+				const operator = assertion.operator ?? "equals";
+				this.obs.logger.info(`Checking property "${assertion.name}" [operator: ${operator}]...`);
+				switch (operator) {
+					case "equals":
+						if (assertion.value === void 0) await asserter.toHaveJSProperty(assertion.name, assertion.options);
+						else {
+							const value = getValueFromPrimitiveOrRegex(assertion.value);
+							this.obs.logger.info(`Expected: "${value}" (timeout: ${assertion.options?.timeout ?? "default"}ms)`);
+							await asserter.toHaveJSProperty(assertion.name, value, assertion.options);
+						}
+						break;
+					case "notEquals":
+						if (assertion.value !== void 0) {
+							const value = getValueFromPrimitiveOrRegex(assertion.value);
+							this.obs.logger.info(`Expected NOT: "${value}"`);
+							await expect(locator).not.toHaveJSProperty(assertion.name, value, assertion.options);
+						}
+						break;
+					case "contains":
+						if (assertion.value !== void 0) {
+							const raw = getValueFromPrimitiveOrRegex(assertion.value);
+							const stringValue = typeof raw === "string" ? raw : String(raw);
+							this.obs.logger.info(`Expected to contain: "${stringValue}"`);
+							const propName = assertion.name;
+							const isTextProp = propName === "textContent" || propName === "innerText";
+							const isHtmlAttr = [
+								"href",
+								"src",
+								"class",
+								"id",
+								"placeholder",
+								"title",
+								"alt",
+								"name",
+								"type",
+								"action",
+								"target",
+								"rel",
+								"value"
+							].includes(propName) || propName.startsWith("data-") || propName.startsWith("aria-");
+							if (isTextProp) await expect(locator).toContainText(stringValue, assertion.options);
+							else if (isHtmlAttr) {
+								const attrPattern = raw instanceof RegExp ? raw : new RegExp(stringValue.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+								await expect(locator).toHaveAttribute(propName, attrPattern, assertion.options);
+							} else {
+								const actual = await locator.evaluate((el, name) => String(el[name] ?? ""), propName);
+								if (!actual.includes(stringValue)) throw new Error(`Property "${propName}" expected to contain "${stringValue}", but got "${actual}"`);
+							}
+						}
+						break;
+					case "lessThan":
+						if (assertion.value !== void 0) {
+							const threshold = Number(getValueFromPrimitiveOrRegex(assertion.value));
+							const actual = Number(await locator.evaluate((el, name) => el[name], assertion.name));
+							this.obs.logger.info(`Expected "${assertion.name}" (${actual}) < ${threshold}`);
+							if (!(actual < threshold)) throw new Error(`Property "${assertion.name}" expected to be less than ${threshold}, but got ${actual}`);
+						}
+						break;
+					case "greaterThan":
+						if (assertion.value !== void 0) {
+							const threshold = Number(getValueFromPrimitiveOrRegex(assertion.value));
+							const actual = Number(await locator.evaluate((el, name) => el[name], assertion.name));
+							this.obs.logger.info(`Expected "${assertion.name}" (${actual}) > ${threshold}`);
+							if (!(actual > threshold)) throw new Error(`Property "${assertion.name}" expected to be greater than ${threshold}, but got ${actual}`);
+						}
+						break;
+					case "exists": {
+						const exists = await locator.evaluate((el, name) => el[name] !== void 0, assertion.name);
+						this.obs.logger.info(`Expected property "${assertion.name}" to exist: ${exists}`);
+						if (!exists) throw new Error(`Property "${assertion.name}" does not exist on element`);
+						break;
+					}
 				}
 				break;
+			}
 			case "toHaveValue": {
 				const value = getValueFromStringOrRegex(assertion.value);
 				await asserter.toHaveValue(value, assertion.options);
@@ -27585,7 +27689,7 @@ var Tester = class {
 					const selectorInfo = target.uniqueSelectors[chosenSelectorIndex];
 					if (!selectorInfo) throw new Error(`No selector found for target "${target.name}" at chosenSelectorIndex ${chosenSelectorIndex}. Available selectors: ${JSON.stringify(target.uniqueSelectors)}`);
 					const frame = await this.getFrame(input.page, target.frames);
-					const locator = this.getLocator(frame, selectorInfo);
+					const locator = this.getLocator(frame, selectorInfo, target);
 					try {
 						const dataWithDefaultTimeout = {
 							...data,
@@ -27606,7 +27710,7 @@ var Tester = class {
 					for (let i = 0; i < target.uniqueSelectors.length; i++) {
 						if (i === chosenSelectorIndex) continue;
 						const selectorInfo = target.uniqueSelectors[i];
-						const locator = this.getLocator(frame, selectorInfo);
+						const locator = this.getLocator(frame, selectorInfo, target);
 						try {
 							this.obs.logger.info(`Retrying action "${data.type}" using next selector: ${JSON.stringify(selectorInfo)}`);
 							const dataWithModifiedTimeout = {
@@ -27637,7 +27741,7 @@ var Tester = class {
 					const chosenSelectorIndex = target.chosenSelectorIndex ?? 0;
 					const selectorInfo = target.uniqueSelectors[chosenSelectorIndex];
 					const frame = await this.getFrame(input.page, target.frames);
-					const locator = this.getLocator(frame, selectorInfo);
+					const locator = this.getLocator(frame, selectorInfo, target);
 					try {
 						this.obs.logger.info(`Executing assertion "${data.type}" using selector: ${JSON.stringify(selectorInfo)}`);
 						const dataWithDefaultTimeout = {
@@ -27657,7 +27761,7 @@ var Tester = class {
 					for (let i = 0; i < target.uniqueSelectors.length; i++) {
 						if (i === chosenSelectorIndex) continue;
 						const selectorInfo = target.uniqueSelectors[i];
-						const locator = this.getLocator(frame, selectorInfo);
+						const locator = this.getLocator(frame, selectorInfo, target);
 						const dataWithModifiedTimeout = {
 							...data,
 							options: {
@@ -27690,7 +27794,7 @@ var Tester = class {
 					const selectorInfo = target.uniqueSelectors[chosenSelectorIndex];
 					if (!selectorInfo) throw new Error(`No selector found for target "${target.name}" at chosenSelectorIndex ${chosenSelectorIndex}. Available selectors: ${JSON.stringify(target.uniqueSelectors)}`);
 					const frame = await this.getFrame(input.page, target.frames);
-					const locator = this.getLocator(frame, selectorInfo);
+					const locator = this.getLocator(frame, selectorInfo, target);
 					try {
 						this.obs.logger.info(`Executing extraction "${extract.type}" using selector: ${JSON.stringify(selectorInfo)}`);
 						await this.executeElementExtraction(locator.target, extract, storageDetails);
@@ -27703,7 +27807,7 @@ var Tester = class {
 					for (let i = 0; i < target.uniqueSelectors.length; i++) {
 						if (i === chosenSelectorIndex) continue;
 						const fallbackSelectorInfo = target.uniqueSelectors[i];
-						const fallbackLocator = this.getLocator(frame, fallbackSelectorInfo);
+						const fallbackLocator = this.getLocator(frame, fallbackSelectorInfo, target);
 						try {
 							this.obs.logger.info(`Retrying extraction "${extract.type}" using next selector: ${JSON.stringify(fallbackSelectorInfo)}`);
 							await this.executeElementExtraction(fallbackLocator.target, extract, storageDetails);