@uuv/playwright 2.10.0 → 2.11.0

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_scrollbar.ts

@@ -22,7 +22,7 @@ import {
     findWithRoleAndName,
     findWithRoleAndNameAndContent,
     findWithRoleAndNameAndContentDisable,
-    findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContentEnable, findWithRoleAndNameFocused,
     getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
@@ -32,14 +32,23 @@ import { expect } from "@playwright/test";
 
 // Begin of General Section
 
+/**
+ * Selects the element whose [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and accessible [name](https://russmaxdesign.github.io/html-elements-names/) are specified <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
+ * */
 When(`within a scroll bar named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "scrollbar", name);
 });
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(`I should see a scroll bar named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "scrollbar", name);
 });
 
+/**
+ * Checks that an Html element does not exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(
     `I should not see a scroll bar named {string}`,
     async function (this: World, name: string)  {
@@ -50,6 +59,9 @@ Then(
 // End of General Section
 // Begin of Type Section
 
+/**
+ * Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)
+ * */
 When(`I type the sentence {string} in the scroll bar named {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("scrollbar", { name: name, includeHidden: true, exact: true });
@@ -62,6 +74,9 @@ When(`I type the sentence {string} in the scroll bar named {string}`, async func
 // End of Type Section
 // Begin of Content Section
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content
+ * */
 Then(
     `I should see a scroll bar named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -69,6 +84,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
+ * */
 Then(
     `I should see a scroll bar named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -76,6 +94,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
+ * */
 Then(
     `I should see a scroll bar named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -84,3 +105,5 @@ Then(
 );
 
 // End of Content Section
+
+

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_search.ts

@@ -22,7 +22,7 @@ import {
     findWithRoleAndName,
     findWithRoleAndNameAndContent,
     findWithRoleAndNameAndContentDisable,
-    findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContentEnable, findWithRoleAndNameFocused,
     getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
@@ -32,14 +32,23 @@ import { expect } from "@playwright/test";
 
 // Begin of General Section
 
+/**
+ * Selects the element whose [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and accessible [name](https://russmaxdesign.github.io/html-elements-names/) are specified <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
+ * */
 When(`within a search named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "search", name);
 });
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(`I should see a search named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "search", name);
 });
 
+/**
+ * Checks that an Html element does not exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(
     `I should not see a search named {string}`,
     async function (this: World, name: string)  {
@@ -50,6 +59,9 @@ Then(
 // End of General Section
 // Begin of Type Section
 
+/**
+ * Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)
+ * */
 When(`I type the sentence {string} in the search named {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("search", { name: name, includeHidden: true, exact: true });
@@ -62,6 +74,9 @@ When(`I type the sentence {string} in the search named {string}`, async function
 // End of Type Section
 // Begin of Content Section
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content
+ * */
 Then(
     `I should see a search named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -69,6 +84,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
+ * */
 Then(
     `I should see a search named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -76,6 +94,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
+ * */
 Then(
     `I should see a search named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -84,3 +105,17 @@ Then(
 );
 
 // End of Content Section
+
+// Begin of Keyboard Section
+
+/**
+ * Checks that the Html element with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/) is focused
+ * */
+Then(
+    `I should see a search named {string} keyboard focused`,
+    async function (this: World, name: string)  {
+        await findWithRoleAndNameFocused(this, "search", name);
+    }
+);
+
+// End of Keyboard Section

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_searchbox.ts

@@ -22,7 +22,7 @@ import {
     findWithRoleAndName,
     findWithRoleAndNameAndContent,
     findWithRoleAndNameAndContentDisable,
-    findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContentEnable, findWithRoleAndNameFocused,
     getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
@@ -32,14 +32,23 @@ import { expect } from "@playwright/test";
 
 // Begin of General Section
 
+/**
+ * Selects the element whose [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and accessible [name](https://russmaxdesign.github.io/html-elements-names/) are specified <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
+ * */
 When(`within a search box named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "searchbox", name);
 });
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(`I should see a search box named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "searchbox", name);
 });
 
+/**
+ * Checks that an Html element does not exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(
     `I should not see a search box named {string}`,
     async function (this: World, name: string)  {
@@ -50,6 +59,9 @@ Then(
 // End of General Section
 // Begin of Type Section
 
+/**
+ * Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)
+ * */
 When(`I type the sentence {string} in the search box named {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("searchbox", { name: name, includeHidden: true, exact: true });
@@ -62,6 +74,9 @@ When(`I type the sentence {string} in the search box named {string}`, async func
 // End of Type Section
 // Begin of Content Section
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content
+ * */
 Then(
     `I should see a search box named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -69,6 +84,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
+ * */
 Then(
     `I should see a search box named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -76,6 +94,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
+ * */
 Then(
     `I should see a search box named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -84,3 +105,17 @@ Then(
 );
 
 // End of Content Section
+
+// Begin of Keyboard Section
+
+/**
+ * Checks that the Html element with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/) is focused
+ * */
+Then(
+    `I should see a search box named {string} keyboard focused`,
+    async function (this: World, name: string)  {
+        await findWithRoleAndNameFocused(this, "searchbox", name);
+    }
+);
+
+// End of Keyboard Section

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_section.ts

@@ -22,7 +22,7 @@ import {
     findWithRoleAndName,
     findWithRoleAndNameAndContent,
     findWithRoleAndNameAndContentDisable,
-    findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContentEnable, findWithRoleAndNameFocused,
     getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
@@ -32,14 +32,23 @@ import { expect } from "@playwright/test";
 
 // Begin of General Section
 
+/**
+ * Selects the element whose [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and accessible [name](https://russmaxdesign.github.io/html-elements-names/) are specified <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
+ * */
 When(`within a section named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "section", name);
 });
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(`I should see a section named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "section", name);
 });
 
+/**
+ * Checks that an Html element does not exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(
     `I should not see a section named {string}`,
     async function (this: World, name: string)  {
@@ -50,6 +59,9 @@ Then(
 // End of General Section
 // Begin of Type Section
 
+/**
+ * Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)
+ * */
 When(`I type the sentence {string} in the section named {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("section", { name: name, includeHidden: true, exact: true });
@@ -62,6 +74,9 @@ When(`I type the sentence {string} in the section named {string}`, async functio
 // End of Type Section
 // Begin of Content Section
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content
+ * */
 Then(
     `I should see a section named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -69,6 +84,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
+ * */
 Then(
     `I should see a section named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -76,6 +94,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
+ * */
 Then(
     `I should see a section named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -84,3 +105,5 @@ Then(
 );
 
 // End of Content Section
+
+

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_sectionhead.ts

@@ -22,7 +22,7 @@ import {
     findWithRoleAndName,
     findWithRoleAndNameAndContent,
     findWithRoleAndNameAndContentDisable,
-    findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContentEnable, findWithRoleAndNameFocused,
     getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
@@ -32,14 +32,23 @@ import { expect } from "@playwright/test";
 
 // Begin of General Section
 
+/**
+ * Selects the element whose [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and accessible [name](https://russmaxdesign.github.io/html-elements-names/) are specified <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
+ * */
 When(`within a section header named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "sectionhead", name);
 });
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(`I should see a section header named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "sectionhead", name);
 });
 
+/**
+ * Checks that an Html element does not exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(
     `I should not see a section header named {string}`,
     async function (this: World, name: string)  {
@@ -50,6 +59,9 @@ Then(
 // End of General Section
 // Begin of Type Section
 
+/**
+ * Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)
+ * */
 When(`I type the sentence {string} in the section header named {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("sectionhead", { name: name, includeHidden: true, exact: true });
@@ -62,6 +74,9 @@ When(`I type the sentence {string} in the section header named {string}`, async
 // End of Type Section
 // Begin of Content Section
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content
+ * */
 Then(
     `I should see a section header named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -69,6 +84,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
+ * */
 Then(
     `I should see a section header named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -76,6 +94,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
+ * */
 Then(
     `I should see a section header named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -84,3 +105,5 @@ Then(
 );
 
 // End of Content Section
+
+

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_select.ts

@@ -22,7 +22,7 @@ import {
     findWithRoleAndName,
     findWithRoleAndNameAndContent,
     findWithRoleAndNameAndContentDisable,
-    findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContentEnable, findWithRoleAndNameFocused,
     getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
@@ -32,14 +32,23 @@ import { expect } from "@playwright/test";
 
 // Begin of General Section
 
+/**
+ * Selects the element whose [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and accessible [name](https://russmaxdesign.github.io/html-elements-names/) are specified <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
+ * */
 When(`within a select named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "select", name);
 });
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(`I should see a select named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "select", name);
 });
 
+/**
+ * Checks that an Html element does not exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(
     `I should not see a select named {string}`,
     async function (this: World, name: string)  {
@@ -50,6 +59,9 @@ Then(
 // End of General Section
 // Begin of Type Section
 
+/**
+ * Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)
+ * */
 When(`I type the sentence {string} in the select named {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("select", { name: name, includeHidden: true, exact: true });
@@ -62,6 +74,9 @@ When(`I type the sentence {string} in the select named {string}`, async function
 // End of Type Section
 // Begin of Content Section
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content
+ * */
 Then(
     `I should see a select named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -69,6 +84,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
+ * */
 Then(
     `I should see a select named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -76,6 +94,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
+ * */
 Then(
     `I should see a select named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -84,3 +105,17 @@ Then(
 );
 
 // End of Content Section
+
+// Begin of Keyboard Section
+
+/**
+ * Checks that the Html element with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/) is focused
+ * */
+Then(
+    `I should see a select named {string} keyboard focused`,
+    async function (this: World, name: string)  {
+        await findWithRoleAndNameFocused(this, "select", name);
+    }
+);
+
+// End of Keyboard Section

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_separator.ts

@@ -22,7 +22,7 @@ import {
     findWithRoleAndName,
     findWithRoleAndNameAndContent,
     findWithRoleAndNameAndContentDisable,
-    findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContentEnable, findWithRoleAndNameFocused,
     getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
@@ -32,14 +32,23 @@ import { expect } from "@playwright/test";
 
 // Begin of General Section
 
+/**
+ * Selects the element whose [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and accessible [name](https://russmaxdesign.github.io/html-elements-names/) are specified <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
+ * */
 When(`within a separator named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "separator", name);
 });
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(`I should see a separator named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "separator", name);
 });
 
+/**
+ * Checks that an Html element does not exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(
     `I should not see a separator named {string}`,
     async function (this: World, name: string)  {
@@ -50,6 +59,9 @@ Then(
 // End of General Section
 // Begin of Type Section
 
+/**
+ * Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)
+ * */
 When(`I type the sentence {string} in the separator named {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("separator", { name: name, includeHidden: true, exact: true });
@@ -62,6 +74,9 @@ When(`I type the sentence {string} in the separator named {string}`, async funct
 // End of Type Section
 // Begin of Content Section
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content
+ * */
 Then(
     `I should see a separator named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -69,6 +84,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
+ * */
 Then(
     `I should see a separator named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -76,6 +94,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
+ * */
 Then(
     `I should see a separator named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -84,3 +105,5 @@ Then(
 );
 
 // End of Content Section
+
+

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_slider.ts

@@ -22,7 +22,7 @@ import {
     findWithRoleAndName,
     findWithRoleAndNameAndContent,
     findWithRoleAndNameAndContentDisable,
-    findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContentEnable, findWithRoleAndNameFocused,
     getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
@@ -32,14 +32,23 @@ import { expect } from "@playwright/test";
 
 // Begin of General Section
 
+/**
+ * Selects the element whose [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and accessible [name](https://russmaxdesign.github.io/html-elements-names/) are specified <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
+ * */
 When(`within a slider named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "slider", name);
 });
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(`I should see a slider named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "slider", name);
 });
 
+/**
+ * Checks that an Html element does not exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(
     `I should not see a slider named {string}`,
     async function (this: World, name: string)  {
@@ -50,6 +59,9 @@ Then(
 // End of General Section
 // Begin of Type Section
 
+/**
+ * Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)
+ * */
 When(`I type the sentence {string} in the slider named {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("slider", { name: name, includeHidden: true, exact: true });
@@ -62,6 +74,9 @@ When(`I type the sentence {string} in the slider named {string}`, async function
 // End of Type Section
 // Begin of Content Section
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content
+ * */
 Then(
     `I should see a slider named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -69,6 +84,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
+ * */
 Then(
     `I should see a slider named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -76,6 +94,9 @@ Then(
     }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
+ * */
 Then(
     `I should see a slider named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
@@ -84,3 +105,17 @@ Then(
 );
 
 // End of Content Section
+
+// Begin of Keyboard Section
+
+/**
+ * Checks that the Html element with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/) is focused
+ * */
+Then(
+    `I should see a slider named {string} keyboard focused`,
+    async function (this: World, name: string)  {
+        await findWithRoleAndNameFocused(this, "slider", name);
+    }
+);
+
+// End of Keyboard Section