@uuv/runner-commons 2.4.1 → 2.6.0

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+## [2.6.0](https://github.com/Orange-OpenSource/uuv/compare/runner-commons-v2.5.0...runner-commons-v2.6.0) (2024-02-02)
+
+
+### Features
+
+* rationalize list sentences, [#453](https://github.com/Orange-OpenSource/uuv/issues/453) ([dd98466](https://github.com/Orange-OpenSource/uuv/commit/dd98466f025a61d9ec007001b0a05de2482adef6))
+* setup role based parameters shouldGenerateContainsSentence & shouldGenerateTypeSentence, [#453](https://github.com/Orange-OpenSource/uuv/issues/453) ([613b821](https://github.com/Orange-OpenSource/uuv/commit/613b821fadc70040fbfd4a27cc57b2197cc674bc))
+
+## [2.5.0](https://github.com/Orange-OpenSource/uuv/compare/runner-commons-v2.4.1...runner-commons-v2.5.0) (2024-01-23)
+
+
+### Features
+
+* **a11y:** add RGAA 1.1.6 and 1.1.3, [#429](https://github.com/Orange-OpenSource/uuv/issues/429) ([0e65889](https://github.com/Orange-OpenSource/uuv/commit/0e65889b479651c27e16c29fdb8e5123fe689f03))
+
+
+### Bug Fixes
+
+* **runner-playwright:** update dependency axe-core to v4.8.3 ([4623485](https://github.com/Orange-OpenSource/uuv/commit/46234851677cf0e5f0479fe30bc786ae2a607f1e))
+
 ## [2.4.1](https://github.com/Orange-OpenSource/uuv/compare/runner-commons-v2.4.0...runner-commons-v2.4.1) (2024-01-21)
 
 

package/dist/assets/i18n/web/en/en-enriched-wordings.json

@@ -3,37 +3,44 @@
         {
             "key": "key.when.withinElement.roleAndName",
             "description": "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",
-            "wording": "within $indefiniteArticle $roleName named {string}"
+            "wording": "within $indefiniteArticle $roleName named {string}",
+            "section": "general"
         },
         {
             "key": "key.then.element.withRoleAndName",
             "description": "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/)",
-            "wording": "I should see $indefiniteArticle $roleName named {string}"
+            "wording": "I should see $indefiniteArticle $roleName named {string}",
+            "section": "general"
         },
         {
             "key": "key.then.element.not.withRoleAndName",
             "description": "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/)",
-            "wording": "I should not see $indefiniteArticle $roleName named {string}"
+            "wording": "I should not see $indefiniteArticle $roleName named {string}",
+            "section": "general"
         },
         {
             "key": "key.then.element.withRoleAndNameAndContent",
             "description": "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",
-            "wording": "I should see $indefiniteArticle $roleName named {string} and containing {string}"
+            "wording": "I should see $indefiniteArticle $roleName named {string} and containing {string}",
+            "section": "contains"
         },
         {
             "key": "key.then.element.withRoleAndNameAndContentDisabled",
             "description": "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",
-            "wording": "I should see $indefiniteArticle $roleName named {string} and containing {string} disabled"
+            "wording": "I should see $indefiniteArticle $roleName named {string} and containing {string} disabled",
+            "section": "contains"
         },
         {
             "key": "key.then.element.withRoleAndNameAndContentEnabled",
             "description": "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",
-            "wording": "I should see $indefiniteArticle $roleName named {string} and containing {string} enabled"
+            "wording": "I should see $indefiniteArticle $roleName named {string} and containing {string} enabled",
+            "section": "contains"
         },
         {
             "key": "key.when.type",
             "description": "Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)",
-            "wording": "I type the sentence {string} in $definiteArticle $roleName named {string}"
+            "wording": "I type the sentence {string} in $definiteArticle $roleName named {string}",
+            "section": "type"
         }
     ]
 }

package/dist/assets/i18n/web/en/en-roles.js

@@ -12,21 +12,23 @@ var INDEFINITE_ARTICLE;
     INDEFINITE_ARTICLE["AN"] = "an";
 })(INDEFINITE_ARTICLE || (INDEFINITE_ARTICLE = {}));
 class EnAccessibleRole extends accessible_role_1.AccessibleRole {
-    definiteArticle = DEFINITE_ARTICLE.THE;
-    indefiniteArticle = INDEFINITE_ARTICLE.A;
-    constructor(id, name, definiteArticle, indefiniteArticle) {
+    id;
+    name;
+    definiteArticle;
+    indefiniteArticle;
+    shouldGenerateTypeSentence;
+    shouldGenerateContainsSentence;
+    constructor(id, name, definiteArticle = DEFINITE_ARTICLE.THE, indefiniteArticle = INDEFINITE_ARTICLE.A, shouldGenerateTypeSentence = true, shouldGenerateContainsSentence = true) {
         super();
         this.id = id;
         this.name = name;
-        if (definiteArticle) {
-            this.definiteArticle = definiteArticle;
-        }
-        if (indefiniteArticle) {
-            this.indefiniteArticle = indefiniteArticle;
-        }
+        this.definiteArticle = definiteArticle;
+        this.indefiniteArticle = indefiniteArticle;
+        this.shouldGenerateTypeSentence = shouldGenerateTypeSentence;
+        this.shouldGenerateContainsSentence = shouldGenerateContainsSentence;
     }
     static from(input) {
-        return new EnAccessibleRole(input.id, input.name, input.definiteArticle, input.indefiniteArticle);
+        return new EnAccessibleRole(input.id, input.name, input.definiteArticle, input.indefiniteArticle, input.shouldGenerateTypeSentence, input.shouldGenerateContainsSentence);
     }
     getDefiniteArticle() {
         return this.definiteArticle.toString();
@@ -73,7 +75,7 @@ exports.EN_ROLES = [
     { id: "input", name: "entry", indefiniteArticle: INDEFINITE_ARTICLE.AN },
     { id: "landmark", name: "landmark" },
     { id: "link", name: "link" },
-    { id: "list", name: "list" },
+    { id: "list", name: "list", shouldGenerateContainsSentence: false, shouldGenerateTypeSentence: false },
     { id: "listbox", name: "list box" },
     { id: "listitem", name: "list item" },
     { id: "log", name: "log" },

package/dist/assets/i18n/web/en/en.json

@@ -156,8 +156,8 @@
     },
     {
         "key": "key.then.list.withNameAndContent",
-        "description": "Checks that there is a list with the specified [name](https://russmaxdesign.github.io/html-elements-names/) and content.<br/> See this <a href='https://github.com/Orange-OpenSource/uuv/blob/9e3c9914420c6d527f7ad8b0017a0f8e26250f86/example/weather-app.feature#L17'>example</a>",
-        "wording": "I should see elements of the list with name {string}"
+        "description": "Checks that there is a list with the specified [name](https://russmaxdesign.github.io/html-elements-names/) containing list items.<br/> <u>Example</u>\\n```gherkin\\nThen I should see a list named \"test-list\" and containing\\n| First element   |\\n| Second element  |\\n| Third element   |\\n```",
+        "wording": "I should see a list named {string} and containing"
     },
     {
         "key": "key.then.element.not.withContent",

package/dist/assets/i18n/web/fr/fr-roles.js

@@ -14,14 +14,20 @@ var FR_INDEFINITE_ARTICLE;
     FR_INDEFINITE_ARTICLE["UNE"] = "une";
 })(FR_INDEFINITE_ARTICLE || (FR_INDEFINITE_ARTICLE = {}));
 class FrAccessibleRole extends accessible_role_1.AccessibleRole {
+    id;
+    name;
     definiteArticle;
     indefiniteArticle;
-    constructor(id, name, definiteArticle, indefiniteArticle) {
+    shouldGenerateTypeSentence;
+    shouldGenerateContainsSentence;
+    constructor(id, name, definiteArticle, indefiniteArticle, shouldGenerateTypeSentence = true, shouldGenerateContainsSentence = true) {
         super();
         this.id = id;
         this.name = name;
         this.definiteArticle = definiteArticle;
         this.indefiniteArticle = indefiniteArticle;
+        this.shouldGenerateTypeSentence = shouldGenerateTypeSentence;
+        this.shouldGenerateContainsSentence = shouldGenerateContainsSentence;
     }
     getDefiniteArticle() {
         return this.definiteArticle.toString();
@@ -237,7 +243,9 @@ exports.FR_ROLES = [
         id: "list",
         name: "liste",
         definiteArticle: FR_DEFINITE_ARTICLE.LA,
-        indefiniteArticle: FR_INDEFINITE_ARTICLE.UNE
+        indefiniteArticle: FR_INDEFINITE_ARTICLE.UNE,
+        shouldGenerateContainsSentence: false,
+        shouldGenerateTypeSentence: false
     },
     {
         id: "listbox",
@@ -557,4 +565,4 @@ exports.FR_ROLES = [
         definiteArticle: FR_DEFINITE_ARTICLE.LA,
         indefiniteArticle: FR_INDEFINITE_ARTICLE.UNE
     }
-].map(role => new FrAccessibleRole(role.id, role.name, role.definiteArticle, role.indefiniteArticle));
+].map((role) => new FrAccessibleRole(role.id, role.name, role.definiteArticle, role.indefiniteArticle, role.shouldGenerateContainsSentence, role.shouldGenerateContainsSentence));

package/dist/step-definition-generator/accessible-role.d.ts

@@ -1,6 +1,8 @@
 export declare abstract class AccessibleRole {
     id: string;
     name: string;
+    shouldGenerateTypeSentence: boolean;
+    shouldGenerateContainsSentence: boolean;
     abstract getDefiniteArticle(): string;
     abstract getIndefiniteArticle(): string;
     abstract getOfDefiniteArticle(): string;

package/dist/step-definition-generator/accessible-role.js

@@ -4,5 +4,7 @@ exports.AccessibleRole = void 0;
 class AccessibleRole {
     id;
     name;
+    shouldGenerateTypeSentence;
+    shouldGenerateContainsSentence;
 }
 exports.AccessibleRole = AccessibleRole;

package/dist/step-definition-generator/generate-based-role-step-definitions.js

@@ -91,6 +91,14 @@ class BasedRoleStepDefinition extends common_1.GenerateFileProcessing {
                     .replaceAll("$ofDefiniteArticle", role.getOfDefiniteArticle())
                     .replaceAll(conf.key + ".description", conf.description);
             });
+            // Exclude Role based Content sentence if specified
+            if (!role.shouldGenerateContainsSentence) {
+                dataUpdated = dataUpdated.replace(/\/\/ Begin of Content Section[\s\S]*?\/\/ End of Content Section/, "");
+            }
+            // Exclude Role based Type sentence if specified
+            if (!role.shouldGenerateTypeSentence) {
+                dataUpdated = dataUpdated.replace(/\/\/ Begin of Type Section[\s\S]*?\/\/ End of Type Section/, "");
+            }
             const generatedFilename = generatedFile.replace("$roleId", role.id);
             // console.debug(">>> data", dataUpdated)
             // console.debug(">>> generatedFilename", generatedFilename)

package/dist/step-definition-generator/generate-step-definitions-documentation.js

@@ -130,17 +130,17 @@ function runGenerateDoc(destDir) {
                 .replaceAll("$namedAdjective", role.namedAdjective())
                 .replaceAll("$ofDefiniteArticle", role.getOfDefiniteArticle());
             const wordingsEnrichedJson = JSON.parse(dataUpdated);
-            const { step: enrichedGiven, autocompletionSuggestions: enrichedGivenAutocompletionSuggestions } = computeStepDefinition(wordingsEnrichedJson.enriched, "key.given", undefined, "####");
+            const { step: enrichedGiven, autocompletionSuggestions: enrichedGivenAutocompletionSuggestions } = computeStepDefinition(wordingsEnrichedJson.enriched, "key.given", undefined, "####", role);
             if (enrichedGiven.length > 1) {
                 rows.push(...enrichedGiven);
                 autocompletionSuggestions.push(...enrichedGivenAutocompletionSuggestions);
             }
-            const { step: enrichedWhen, autocompletionSuggestions: enrichedWhenAutocompletionSuggestions } = computeStepDefinition(wordingsEnrichedJson.enriched, "key.when", undefined, "####");
+            const { step: enrichedWhen, autocompletionSuggestions: enrichedWhenAutocompletionSuggestions } = computeStepDefinition(wordingsEnrichedJson.enriched, "key.when", undefined, "####", role);
             if (enrichedWhen.length > 1) {
                 rows.push(...enrichedWhen);
                 autocompletionSuggestions.push(...enrichedWhenAutocompletionSuggestions);
             }
-            const { step: enrichedThen, autocompletionSuggestions: enrichedThenAutocompletionSuggestions } = computeStepDefinition(wordingsEnrichedJson.enriched, "key.then", undefined, "####");
+            const { step: enrichedThen, autocompletionSuggestions: enrichedThenAutocompletionSuggestions } = computeStepDefinition(wordingsEnrichedJson.enriched, "key.then", undefined, "####", role);
             if (enrichedThen.length > 1) {
                 rows.push(...enrichedThen);
                 autocompletionSuggestions.push(...enrichedThenAutocompletionSuggestions);
@@ -152,17 +152,27 @@ function runGenerateDoc(destDir) {
         };
     }
     /* eslint-disable  @typescript-eslint/no-explicit-any */
-    function computeStepDefinition(wordingsJson, stepKey, stepTitle, level = "###") {
+    function computeStepDefinition(wordingsJson, stepKey, stepTitle, level = "###", role) {
         const step = [];
         const autocompletionSuggestion = [];
         if (stepTitle) {
             step.push(stepTitle);
         }
         wordingsJson.forEach((conf) => {
-            if (conf.key.startsWith(stepKey)) {
+            if (conf.key.startsWith(stepKey) && shouldGenerate(conf, role)) {
                 const wording = `${level} ${conf.wording}`;
                 step.push(wording);
-                step.push(`> ${conf.description ?? ""}\n`);
+                conf.description?.split("\\n").forEach((descriptionLine, index, array) => {
+                    if (index === 0) {
+                        step.push(`> ${descriptionLine ?? ""}`);
+                    }
+                    else if (index === array.length - 1) {
+                        step.push(` ${descriptionLine ?? ""}\n`);
+                    }
+                    else {
+                        step.push(` ${descriptionLine ?? ""}`);
+                    }
+                });
                 autocompletionSuggestion.push({
                     suggestion: conf.wording
                         .replaceAll("\\", ""),
@@ -182,6 +192,19 @@ function runGenerateDoc(destDir) {
             autocompletionSuggestions: autocompletionSuggestion
         };
     }
+    function shouldGenerate(wordingsConf, role) {
+        if (role === undefined) {
+            return true;
+        }
+        switch (wordingsConf.section) {
+            case "contains":
+                return role.shouldGenerateContainsSentence;
+            case "type":
+                return role.shouldGenerateTypeSentence;
+            default:
+                return true;
+        }
+    }
     function writeWordingFile(generatedFile, data, lang, indexOfFile) {
         fs_1.default.writeFileSync(generatedFile, data);
         console.log(`[WRITE] ${indexOfFile}-${lang}-generated-wording-description.md written successfully`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uuv/runner-commons",
-  "version": "2.4.1",
+  "version": "2.6.0",
   "type": "commonjs",
   "author": "Louis Fredice NJAKO MOLOM (https://github.com/luifr10) & Stanley SERVICAL (https://github.com/stanlee974)",
   "description": "A common lib for uuv",

package/src/assets/i18n/web/en/en-enriched-wordings.json

@@ -3,37 +3,44 @@
     {
       "key": "key.when.withinElement.roleAndName",
       "description": "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",
-      "wording": "within $indefiniteArticle $roleName named {string}"
+      "wording": "within $indefiniteArticle $roleName named {string}",
+      "section": "general"
     },
     {
       "key": "key.then.element.withRoleAndName",
       "description": "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/)",
-      "wording": "I should see $indefiniteArticle $roleName named {string}"
+      "wording": "I should see $indefiniteArticle $roleName named {string}",
+      "section": "general"
     },
     {
       "key": "key.then.element.not.withRoleAndName",
       "description": "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/)",
-      "wording": "I should not see $indefiniteArticle $roleName named {string}"
+      "wording": "I should not see $indefiniteArticle $roleName named {string}",
+      "section": "general"
     },
     {
       "key": "key.then.element.withRoleAndNameAndContent",
       "description": "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",
-      "wording": "I should see $indefiniteArticle $roleName named {string} and containing {string}"
+      "wording": "I should see $indefiniteArticle $roleName named {string} and containing {string}",
+      "section": "contains"
     },
     {
       "key": "key.then.element.withRoleAndNameAndContentDisabled",
       "description": "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",
-      "wording": "I should see $indefiniteArticle $roleName named {string} and containing {string} disabled"
+      "wording": "I should see $indefiniteArticle $roleName named {string} and containing {string} disabled",
+      "section": "contains"
     },
     {
       "key": "key.then.element.withRoleAndNameAndContentEnabled",
       "description": "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",
-      "wording": "I should see $indefiniteArticle $roleName named {string} and containing {string} enabled"
+      "wording": "I should see $indefiniteArticle $roleName named {string} and containing {string} enabled",
+      "section": "contains"
     },
     {
       "key": "key.when.type",
       "description": "Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)",
-      "wording": "I type the sentence {string} in $definiteArticle $roleName named {string}"
+      "wording": "I type the sentence {string} in $definiteArticle $roleName named {string}",
+      "section": "type"
     }
   ]
 }

package/src/assets/i18n/web/en/en.json

@@ -156,8 +156,8 @@
  },
  {
   "key": "key.then.list.withNameAndContent",
-  "description": "Checks that there is a list with the specified [name](https://russmaxdesign.github.io/html-elements-names/) and content.<br/> See this <a href='https://github.com/Orange-OpenSource/uuv/blob/9e3c9914420c6d527f7ad8b0017a0f8e26250f86/example/weather-app.feature#L17'>example</a>",
-  "wording": "I should see elements of the list with name {string}"
+  "description": "Checks that there is a list with the specified [name](https://russmaxdesign.github.io/html-elements-names/) containing list items.<br/> <u>Example</u>\\n```gherkin\\nThen I should see a list named \"test-list\" and containing\\n| First element   |\\n| Second element  |\\n| Third element   |\\n```",
+  "wording": "I should see a list named {string} and containing"
  },
  {
   "key": "key.then.element.not.withContent",

package/src/assets/i18n/web/fr/fr-enriched-wordings.json

@@ -3,37 +3,44 @@
     {
       "key": "key.when.withinElement.roleAndName",
       "description": "Sélectionne l'élément ayant le rôle $roleId et le [nom accessible](https://russmaxdesign.github.io/html-elements-names/) sont spécifiés <br />⚠ pensez à déselectionner l'élement avec <b>[je reinitialise le contexte](#je-reinitialise-le-contexte)</b> si vous n'agissez plus dessus",
-      "wording": "je vais à l'intérieur $ofDefiniteArticle$roleName $namedAdjective {string}"
+      "wording": "je vais à l'intérieur $ofDefiniteArticle$roleName $namedAdjective {string}",
+      "section": "general"
     },
     {
       "key": "key.then.element.withRoleAndName",
       "description": "Vérifie l'existence d'un élément Html ayant le rôle $roleId et le [nom accessible](https://russmaxdesign.github.io/html-elements-names/) spécifiés",
-      "wording": "je dois voir $indefiniteArticle $roleName $namedAdjective {string}"
+      "wording": "je dois voir $indefiniteArticle $roleName $namedAdjective {string}",
+      "section": "general"
     },
     {
       "key": "key.then.element.not.withRoleAndName",
       "description": "Vérifie l'inexistence d'un élément Html ayant le rôle $roleId et le [nom accessible](https://russmaxdesign.github.io/html-elements-names/) spécifiés",
-      "wording": "je ne dois pas voir $indefiniteArticle $roleName $namedAdjective {string}"
+      "wording": "je ne dois pas voir $indefiniteArticle $roleName $namedAdjective {string}",
+      "section": "general"
     },
     {
       "key": "key.then.element.withRoleAndNameAndContent",
       "description": "Vérifie l'existence d'un élément Html ayant le rôle $roleId, le [nom accessible](https://russmaxdesign.github.io/html-elements-names/) et le contenu spécifiés",
-      "wording": "je dois voir $indefiniteArticle $roleName $namedAdjective {string} et contenant {string}"
+      "wording": "je dois voir $indefiniteArticle $roleName $namedAdjective {string} et contenant {string}",
+      "section": "contains"
     },
     {
       "key": "key.then.element.withRoleAndNameAndContentDisabled",
       "description": "Vérifie l'existence d'un élément Html ayant le rôle $roleId, le [nom accessible](https://russmaxdesign.github.io/html-elements-names/), le contenu spécifiés et avec l'attribut disabled à false",
-      "wording": "je dois voir $indefiniteArticle $roleName $namedAdjective {string} et contenant {string} inactif"
+      "wording": "je dois voir $indefiniteArticle $roleName $namedAdjective {string} et contenant {string} inactif",
+      "section": "contains"
     },
     {
       "key": "key.then.element.withRoleAndNameAndContentEnabled",
       "description": "Vérifie l'existence d'un élément Html ayant le rôle $roleId, le [nom accessible](https://russmaxdesign.github.io/html-elements-names/), le contenu spécifiés et avec l'attribut disabled à true",
-      "wording": "je dois voir $indefiniteArticle $roleName $namedAdjective {string} et contenant {string} actif"
+      "wording": "je dois voir $indefiniteArticle $roleName $namedAdjective {string} et contenant {string} actif",
+      "section": "contains"
     },
     {
       "key": "key.when.type",
       "description": "Saisie de la phrase passée en paramètre dans le champ spécifié(utile par exemple pour remplir un champ de formulaire).",
-      "wording": "je saisie le(s) mot(s) {string} dans $definiteArticle$roleName $namedAdjective {string}"
+      "wording": "je saisie le(s) mot(s) {string} dans $definiteArticle$roleName $namedAdjective {string}",
+      "section": "type"
     }
   ]
 }

package/src/assets/i18n/web/fr/fr.json

@@ -156,8 +156,8 @@
   },
   {
     "key": "key.then.list.withNameAndContent",
-    "description": "Vérifie qu'il existe une liste avec le nom et le contenu spécifiés.<br/>Voici un <a href='https://github.com/Orange-OpenSource/uuv/blob/9e3c9914420c6d527f7ad8b0017a0f8e26250f86/example/weather-app.feature#L17'>exemple</a>",
-    "wording": "je dois voir des elements de la liste ayant pour nom {string}"
+    "description": "Vérifie qu'il existe une liste avec le nom et les éléments de liste spécifiés.<br/> <u>Exemple</u>\\n```gherkin\\nAlors je dois voir une liste nommée \"test-list\" et contenant\\n| Premier élément   |\\n| Deuxième élément  |\\n| Troisième élément   |\\n```",
+    "wording": "je dois voir une liste nommée {string} et contenant"
   },
   {
     "key": "key.then.element.not.withContent",