@dev-blinq/bvt-playwright-js 1.0.0-dev.4.latest.138.1 → 1.0.0-dev.4.latest.142.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">;
@@ -2011,6 +2019,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">;
@@ -5010,6 +5026,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">;

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()
 	}),
@@ -6918,6 +6930,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 +6957,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();
@@ -27390,15 +27421,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);