@uuv/playwright 1.14.3 → 1.16.0

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_textbox.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de boîte à texte nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la boîte à texte nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "textbox", name);
 });
 
-Then(`je dois voir un(e) boîte à texte nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une boîte à texte nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "textbox", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) boîte à texte nommé(e) {string}`,
+    `je ne dois pas voir une boîte à texte nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "textbox", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans la boîte à texte nommée {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("textbox", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) boîte à texte nommé(e) {string} et contenant {string}`,
+    `je dois voir une boîte à texte nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "textbox", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) boîte à texte nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une boîte à texte nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "textbox", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) boîte à texte nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une boîte à texte nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "textbox", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_timer.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de minuterie nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la minuterie nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "timer", name);
 });
 
-Then(`je dois voir un(e) minuterie nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une minuterie nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "timer", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) minuterie nommé(e) {string}`,
+    `je ne dois pas voir une minuterie nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "timer", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans la minuterie nommée {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("timer", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) minuterie nommé(e) {string} et contenant {string}`,
+    `je dois voir une minuterie nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "timer", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) minuterie nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une minuterie nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "timer", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) minuterie nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une minuterie nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "timer", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_toolbar.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de barre d'outils nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la barre d'outils nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "toolbar", name);
 });
 
-Then(`je dois voir un(e) barre d'outils nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une barre d'outils nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "toolbar", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) barre d'outils nommé(e) {string}`,
+    `je ne dois pas voir une barre d'outils nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "toolbar", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans la barre d'outils nommée {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("toolbar", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) barre d'outils nommé(e) {string} et contenant {string}`,
+    `je dois voir une barre d'outils nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "toolbar", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) barre d'outils nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une barre d'outils nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "toolbar", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) barre d'outils nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une barre d'outils nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "toolbar", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_tooltip.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de infobulle nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de l'infobulle nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "tooltip", name);
 });
 
-Then(`je dois voir un(e) infobulle nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une infobulle nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "tooltip", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) infobulle nommé(e) {string}`,
+    `je ne dois pas voir une infobulle nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "tooltip", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans l'infobulle nommée {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("tooltip", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) infobulle nommé(e) {string} et contenant {string}`,
+    `je dois voir une infobulle nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "tooltip", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) infobulle nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une infobulle nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "tooltip", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) infobulle nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une infobulle nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "tooltip", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_tree.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de arbre nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de l'arbre nommé {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "tree", name);
 });
 
-Then(`je dois voir un(e) arbre nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir un arbre nommé {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "tree", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) arbre nommé(e) {string}`,
+    `je ne dois pas voir un arbre nommé {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "tree", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans l'arbre nommé {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("tree", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) arbre nommé(e) {string} et contenant {string}`,
+    `je dois voir un arbre nommé {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "tree", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) arbre nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir un arbre nommé {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "tree", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) arbre nommé(e) {string} et contenant {string} actif`,
+    `je dois voir un arbre nommé {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "tree", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_treegrid.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de grille d'arbre nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la grille d'arbre nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "treegrid", name);
 });
 
-Then(`je dois voir un(e) grille d'arbre nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une grille d'arbre nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "treegrid", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) grille d'arbre nommé(e) {string}`,
+    `je ne dois pas voir une grille d'arbre nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "treegrid", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans la grille d'arbre nommée {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("treegrid", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) grille d'arbre nommé(e) {string} et contenant {string}`,
+    `je dois voir une grille d'arbre nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "treegrid", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) grille d'arbre nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une grille d'arbre nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "treegrid", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) grille d'arbre nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une grille d'arbre nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "treegrid", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_treeitem.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de élément d'arbre nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de l'élément d'arbre nommé {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "treeitem", name);
 });
 
-Then(`je dois voir un(e) élément d'arbre nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir un élément d'arbre nommé {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "treeitem", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) élément d'arbre nommé(e) {string}`,
+    `je ne dois pas voir un élément d'arbre nommé {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "treeitem", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans l'élément d'arbre nommé {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("treeitem", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) élément d'arbre nommé(e) {string} et contenant {string}`,
+    `je dois voir un élément d'arbre nommé {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "treeitem", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) élément d'arbre nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir un élément d'arbre nommé {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "treeitem", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) élément d'arbre nommé(e) {string} et contenant {string} actif`,
+    `je dois voir un élément d'arbre nommé {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "treeitem", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_widget.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de widget nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur du widget nommé {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "widget", name);
 });
 
-Then(`je dois voir un(e) widget nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir un widget nommé {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "widget", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) widget nommé(e) {string}`,
+    `je ne dois pas voir un widget nommé {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "widget", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans le widget nommé {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("widget", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) widget nommé(e) {string} et contenant {string}`,
+    `je dois voir un widget nommé {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "widget", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) widget nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir un widget nommé {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "widget", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) widget nommé(e) {string} et contenant {string} actif`,
+    `je dois voir un widget nommé {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "widget", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_window.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de fenêtre nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la fenêtre nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "window", name);
 });
 
-Then(`je dois voir un(e) fenêtre nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une fenêtre nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "window", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) fenêtre nommé(e) {string}`,
+    `je ne dois pas voir une fenêtre nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "window", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans la fenêtre nommée {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("window", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) fenêtre nommé(e) {string} et contenant {string}`,
+    `je dois voir une fenêtre nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "window", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) fenêtre nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une fenêtre nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "window", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) fenêtre nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une fenêtre nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "window", name, expectedTextContent);
     }

package/dist/cucumber/step_definitions/playwright/base-check-engine.d.ts

@@ -1,15 +0,0 @@
-/**
- * Software Name : UUV
- *
- * SPDX-FileCopyrightText: Copyright (c) 2022-2023 Orange
- * SPDX-License-Identifier: MIT
- *
- * This software is distributed under the MIT License,
- * the text of which is available at https://spdx.org/licenses/MIT.html
- * or see the "LICENSE" file for more details.
- *
- * Authors: NJAKO MOLOM Louis Fredice & SERVICAL Stanley
- * Software description: Make test writing fast, understandable by any human
- * understanding English or French.
- */
-export {};