@uuv/assistant 2.72.0 → 2.73.1

package/dist/src/translator/abstract-translator.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Software Name : UUV
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This software is distributed under the MIT License,
+ * 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.
+ */
+import { TranslateSentences } from "./model";
+import { EnDictionary } from "@uuv/dictionary";
+export declare abstract class Translator {
+    protected dictionary: EnDictionary;
+    protected selectedHtmlElem: HTMLElement | SVGElement;
+    translate(htmlElem: HTMLElement | SVGElement): Promise<TranslateSentences>;
+    abstract getSentenceFromDomSelector(htmlElem: HTMLElement | SVGElement): TranslateSentences;
+    abstract getSentenceFromAccessibleRoleAndName(accessibleRole: string, accessibleName: string): TranslateSentences;
+    abstract getSentenceFromAccessibleRoleAndNameAndContent(accessibleRole: string, accessibleName: string, content: string): TranslateSentences;
+    static getSelector(element: any): string;
+    protected initResponse(): TranslateSentences;
+    protected computeSentenceFromKeyRoleAndName(computedKey: string, accessibleRole: string, accessibleName: string): string;
+    protected computeSentenceFromKeyRoleNameAndContent(computedKey: string, accessibleRole: string, accessibleName: string, content: string): string;
+    protected computeSentenceFromKeyAndSelector(computedKey: string, selector: string): string;
+    computeSentenceFromKeyAndContent(computedKey: string, content: string): string;
+    getSentenceFromKey(key: string): import("@uuv/dictionary").BaseSentence;
+}

package/dist/src/translator/abstract-translator.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * Software Name : UUV
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This software is distributed under the MIT License,
+ * 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.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Translator = void 0;
+const dom_accessibility_api_1 = require("dom-accessibility-api");
+const model_1 = require("./model");
+const dictionary_1 = require("@uuv/dictionary");
+class Translator {
+    constructor() {
+        this.dictionary = new dictionary_1.EnDictionary();
+    }
+    translate(htmlElem) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const accessibleRole = (0, dom_accessibility_api_1.getRole)(htmlElem);
+            const accessibleName = (0, dom_accessibility_api_1.computeAccessibleName)(htmlElem);
+            this.selectedHtmlElem = htmlElem;
+            let response = {
+                suggestion: undefined,
+                sentences: []
+            };
+            if (htmlElem.getAttribute("type") !== "hidden") {
+                if (accessibleRole && accessibleName) {
+                    const isInputHtmlOrTextArea = htmlElem instanceof HTMLInputElement || htmlElem instanceof HTMLTextAreaElement;
+                    const content = isInputHtmlOrTextArea ?
+                        /* eslint-disable  @typescript-eslint/no-explicit-any */
+                        htmlElem.value :
+                        (_a = htmlElem.getAttribute("value")) !== null && _a !== void 0 ? _a : (_c = (_b = htmlElem.firstChild) === null || _b === void 0 ? void 0 : _b.textContent) === null || _c === void 0 ? void 0 : _c.trim();
+                    if (content) {
+                        response = this.getSentenceFromAccessibleRoleAndNameAndContent(accessibleRole, accessibleName, content);
+                    }
+                    else {
+                        response = this.getSentenceFromAccessibleRoleAndName(accessibleRole, accessibleName);
+                    }
+                }
+                else {
+                    response = this.getSentenceFromDomSelector(htmlElem);
+                    response.suggestion = new model_1.Suggestion();
+                }
+            }
+            return response;
+        });
+    }
+    /* eslint-disable  @typescript-eslint/no-explicit-any */
+    static getSelector(element) {
+        const path = [];
+        while (element.nodeType === Node.ELEMENT_NODE) {
+            let selector = element.nodeName.toLowerCase();
+            if (element.id) {
+                selector += "#" + element.id;
+                path.unshift(selector);
+                break;
+            }
+            else if (element.getAttribute("data-testid")) {
+                selector += `[data-testid=${element.getAttribute("data-testid")}]`;
+                path.unshift(selector);
+                break;
+            }
+            else {
+                let sibling = element.previousSibling;
+                let index = 1;
+                while (sibling) {
+                    if (sibling.nodeType === Node.ELEMENT_NODE && sibling.nodeName.toLowerCase() === selector) {
+                        index++;
+                    }
+                    sibling = sibling.previousSibling;
+                }
+                if (index > 1 || element.nextSibling) {
+                    selector += ":nth-of-type(" + index + ")";
+                }
+            }
+            path.unshift(selector);
+            element = element.parentNode;
+        }
+        return path.join(" > ");
+    }
+    initResponse() {
+        return {
+            suggestion: undefined,
+            sentences: []
+        };
+    }
+    computeSentenceFromKeyRoleAndName(computedKey, accessibleRole, accessibleName) {
+        return this.dictionary.getRoleBasedSentencesTemplate()
+            .filter(value => value.key === computedKey)
+            .map(sentence => {
+            return this.dictionary.computeSentence({
+                sentence,
+                accessibleRole,
+                parameters: [accessibleName]
+            });
+        })[0];
+    }
+    computeSentenceFromKeyRoleNameAndContent(computedKey, accessibleRole, accessibleName, content) {
+        return this.dictionary.getRoleBasedSentencesTemplate()
+            .filter(value => value.key === computedKey)
+            .map(sentence => {
+            return this.dictionary.computeSentence({
+                sentence,
+                accessibleRole,
+                parameters: [accessibleName, content]
+            });
+        })[0];
+    }
+    computeSentenceFromKeyAndSelector(computedKey, selector) {
+        return this.dictionary.getBaseSentences()
+            .filter((el) => el.key === computedKey)
+            .map((el) => el.wording.replace("{string}", `"${selector}"`))[0];
+    }
+    computeSentenceFromKeyAndContent(computedKey, content) {
+        return this.computeSentenceFromKeyAndSelector(computedKey, content);
+    }
+    getSentenceFromKey(key) {
+        return this.dictionary.getBaseSentences().filter((el) => el.key === key)[0];
+    }
+}
+exports.Translator = Translator;

package/dist/src/translator/click-translator.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Software Name : UUV
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This software is distributed under the MIT License,
+ * 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.
+ */
+import { Translator } from "./abstract-translator";
+import { TranslateSentences } from "./model";
+export declare class ClickTranslator extends Translator {
+    getSentenceFromAccessibleRoleAndName(accessibleRole: string, accessibleName: string): TranslateSentences;
+    getSentenceFromAccessibleRoleAndNameAndContent(accessibleRole: string, accessibleName: string, content: string): TranslateSentences;
+    getSentenceFromDomSelector(htmlElem: HTMLElement | SVGElement): TranslateSentences;
+    private buildSentencesWithRoleAndName;
+    private buildWording;
+}

package/dist/src/translator/click-translator.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Software Name : UUV
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This software is distributed under the MIT License,
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClickTranslator = void 0;
+const abstract_translator_1 = require("./abstract-translator");
+const model_1 = require("./model");
+const stepCase = model_1.StepCaseEnum.WHEN;
+class ClickTranslator extends abstract_translator_1.Translator {
+    getSentenceFromAccessibleRoleAndName(accessibleRole, accessibleName) {
+        const response = this.initResponse();
+        response.sentences = this.buildSentencesWithRoleAndName(accessibleRole, accessibleName);
+        return response;
+    }
+    getSentenceFromAccessibleRoleAndNameAndContent(accessibleRole, accessibleName, content) {
+        return this.getSentenceFromAccessibleRoleAndName(accessibleRole, accessibleName);
+    }
+    getSentenceFromDomSelector(htmlElem) {
+        const response = this.initResponse();
+        const computedKey = "key.when.withinElement.selector";
+        const sentence = this.computeSentenceFromKeyAndSelector(computedKey, abstract_translator_1.Translator.getSelector(htmlElem));
+        const clickSentence = this.getSentenceFromKey("key.when.click.withContext");
+        response.sentences = [stepCase + sentence, model_1.StepCaseEnum.THEN + clickSentence.wording];
+        return response;
+    }
+    buildSentencesWithRoleAndName(accessibleRole, accessibleName) {
+        const role = this.dictionary.getDefinedRoles().find(role => role.shouldGenerateClickSentence && role.id === accessibleRole);
+        if (role) {
+            const wording = this.buildWording("key.when.click", accessibleRole, accessibleName);
+            return [stepCase + wording];
+        }
+        else {
+            const clickSentence = this.getSentenceFromKey("key.when.click.withRole");
+            return [stepCase + clickSentence.wording.replace("{string}", `"${accessibleRole}"`).replace("{string}", `"${accessibleName}"`)];
+        }
+    }
+    /* eslint-disable  @typescript-eslint/no-explicit-any */
+    buildWording(computedKey, accessibleRole, accessibleName) {
+        const clickSentence = [
+            ...this.dictionary.getRoleBasedSentencesTemplate(),
+            ...this.dictionary.getBaseSentences()
+        ].find((el) => (el.key === computedKey));
+        return this.dictionary.computeSentence({
+            sentence: clickSentence,
+            accessibleRole,
+            parameters: [accessibleName]
+        });
+    }
+}
+exports.ClickTranslator = ClickTranslator;

package/dist/src/translator/expect-translator.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Software Name : UUV
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This software is distributed under the MIT License,
+ * 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.
+ */
+import { Translator } from "./abstract-translator";
+import { TranslateSentences } from "./model";
+export declare class ExpectTranslator extends Translator {
+    private buildResponse;
+    getSentenceFromAccessibleRoleAndName(role: string, name: string): TranslateSentences;
+    getSentenceFromAccessibleRoleAndNameAndContent(role: string, name: string, content: string): TranslateSentences;
+    getSentenceFromDomSelector(htmlElem: HTMLElement | SVGElement): TranslateSentences;
+    computeTableSentenceFromKeyNameAndContent(sentenceKey: string, indefiniteArticle: string, roleName: string, accessibleName: string, headers: HTMLElement, rows: HTMLElement[], cellRoleName: string): string;
+    computeDialogSentenceFromKeyNameAndContent(sentenceKey: string, accessibleName: string, row: HTMLElement): Promise<string[]>;
+    private formatMarkdownTable;
+}

package/dist/src/translator/expect-translator.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * Software Name : UUV
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This software is distributed under the MIT License,
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpectTranslator = void 0;
+const Commons_1 = require("../Commons");
+const abstract_translator_1 = require("./abstract-translator");
+const model_1 = require("./model");
+const TextualTranslator = __importStar(require("./textual-translator"));
+const informative_nodes_helper_1 = require("../helper/informative-nodes-helper");
+const dom_accessibility_api_1 = require("dom-accessibility-api");
+const stepCase = model_1.StepCaseEnum.THEN;
+class ExpectTranslator extends abstract_translator_1.Translator {
+    buildResponse(sentences) {
+        const response = this.initResponse();
+        response.sentences = sentences.map(s => stepCase + s);
+        return response;
+    }
+    getSentenceFromAccessibleRoleAndName(role, name) {
+        const key = "key.then.element.withRoleAndName";
+        const sentence = this.computeSentenceFromKeyRoleAndName(key, role, name);
+        return this.buildResponse([sentence]);
+    }
+    getSentenceFromAccessibleRoleAndNameAndContent(role, name, content) {
+        const isDisabled = this.selectedHtmlElem.classList.contains(Commons_1.UUV_DISABLED_CLASS);
+        const key = isDisabled ? "key.then.element.withRoleAndNameAndContentDisabled" : "key.then.element.withRoleAndNameAndContent";
+        const sentence = this.computeSentenceFromKeyRoleNameAndContent(key, role, name, content);
+        return this.buildResponse([sentence]);
+    }
+    getSentenceFromDomSelector(htmlElem) {
+        const key = "key.then.element.withSelector";
+        const sentence = this.computeSentenceFromKeyAndSelector(key, abstract_translator_1.Translator.getSelector(htmlElem));
+        return this.buildResponse([sentence]);
+    }
+    computeTableSentenceFromKeyNameAndContent(sentenceKey, indefiniteArticle, roleName, accessibleName, headers, rows, cellRoleName) {
+        var _a;
+        if (!sentenceKey) {
+            return "";
+        }
+        const baseSentence = this.dictionary.getRoleBasedSentencesTemplate().find((v) => v.key === sentenceKey);
+        const sentenceAvailable = `Then ${(_a = baseSentence === null || baseSentence === void 0 ? void 0 : baseSentence.wording) !== null && _a !== void 0 ? _a : ""}`
+            .replace("$indefiniteArticle", `${indefiniteArticle}`)
+            .replace("$roleName", `${roleName}`)
+            .replace("{string}", `"${accessibleName}"`)
+            .replace("{string}", "");
+        const headerValues = Array.from(headers.querySelectorAll("[role=columnheader], th")).map(c => (0, dom_accessibility_api_1.computeAccessibleName)(c));
+        const tableLines = ["| " + headerValues.join(" | ") + " |", "| " + headerValues.map(() => "---").join(" | ") + " |"];
+        rows.forEach(row => {
+            const values = Array.from(row.querySelectorAll(`[role=${cellRoleName}], td, [role=columnheader], th`)).map(c => {
+                if (c.classList.contains("ag-floating-filter")) {
+                    return Array.from(c.querySelectorAll("[role=button]:not(.ag-hidden [role=button]), button:not(.ag-hidden button)")).reduce((accumulator, button) => accumulator + (accumulator.length > 0 ? " " : "") + (0, dom_accessibility_api_1.computeAccessibleName)(button), "");
+                }
+                return (0, dom_accessibility_api_1.computeAccessibleName)(c);
+            });
+            tableLines.push("| " + values.join(" | ") + " |");
+        });
+        return sentenceAvailable + "\n" + this.formatMarkdownTable(tableLines).join("\n");
+    }
+    computeDialogSentenceFromKeyNameAndContent(sentenceKey, accessibleName, row) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sentences = [`Then ${this.computeSentenceFromKeyRoleAndName(sentenceKey, "dialog", accessibleName)}`];
+            const getSentencesForNode = (node) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                if (TextualTranslator.isTextualNode(node)) {
+                    const res = yield TextualTranslator.computeSentence(node);
+                    return (_a = res === null || res === void 0 ? void 0 : res.sentences) !== null && _a !== void 0 ? _a : [];
+                }
+                const res = yield this.translate(node);
+                return (_b = res === null || res === void 0 ? void 0 : res.sentences) !== null && _b !== void 0 ? _b : [];
+            });
+            const handleElement = (element) => __awaiter(this, void 0, void 0, function* () {
+                if (element.children.length === 1) {
+                    const informativeChildren = yield new informative_nodes_helper_1.InformativeNodesHelper().getAvailableChildren(element);
+                    for (const child of informativeChildren) {
+                        sentences.push(...(yield getSentencesForNode(child)));
+                    }
+                }
+                else {
+                    sentences.push(...(yield getSentencesForNode(element)));
+                }
+            });
+            yield Promise.all(Array.from(row.children).map(el => handleElement(el)));
+            return sentences;
+        });
+    }
+    formatMarkdownTable(lines) {
+        const headerLine = lines.find(line => !/^ *\|? *-+/.test(line));
+        const separatorLine = lines.find(line => /^ *\|? *-+/.test(line));
+        const dataLines = lines.filter(line => line !== headerLine && line !== separatorLine && line.trim());
+        const parse = (line) => line
+            .replace(/^\||\|$/g, "")
+            .split("|")
+            .map(cell => cell.trim());
+        const header = parse(headerLine);
+        const rows = dataLines.map(parse);
+        const colCount = Math.max(header.length, ...rows.map(r => r.length));
+        const colWidths = Array(colCount).fill(0);
+        [header, ...rows].forEach(r => r.forEach((cell, i) => (colWidths[i] = Math.max(colWidths[i], cell.length))));
+        const FORMAT_PREFFIX = "      ";
+        const formatRow = (row) => FORMAT_PREFFIX + "| " + row.map((cell, i) => cell.padEnd(colWidths[i])).join(" | ") + " |";
+        const separator = FORMAT_PREFFIX + "| " + colWidths.map(w => "-".repeat(w)).join(" | ") + " |";
+        return [formatRow(header), separator, ...rows.map(formatRow)];
+    }
+}
+exports.ExpectTranslator = ExpectTranslator;

package/dist/src/translator/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./model";
+export * from "./abstract-translator";
+export * from "./click-translator";
+export * from "./expect-translator";
+export * from "./keyboard-navigation-translator";
+export * from "./textual-translator";
+export * from "./type-translator";
+export * from "./within-translator";

package/dist/src/translator/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./model"), exports);
+__exportStar(require("./abstract-translator"), exports);
+__exportStar(require("./click-translator"), exports);
+__exportStar(require("./expect-translator"), exports);
+__exportStar(require("./keyboard-navigation-translator"), exports);
+__exportStar(require("./textual-translator"), exports);
+__exportStar(require("./type-translator"), exports);
+__exportStar(require("./within-translator"), exports);

package/dist/src/translator/keyboard-navigation-translator.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Software Name : UUV
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This software is distributed under the MIT License,
+ * 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.
+ */
+import { Translator } from "./abstract-translator";
+import { TranslateSentences } from "./model";
+export declare class KeyboardNavigationTranslator extends Translator {
+    getSentenceFromAccessibleRoleAndName(accessibleRole: string, accessibleName: string): TranslateSentences;
+    getSentenceFromAccessibleRoleAndNameAndContent(accessibleRole: string, accessibleName: string, content: string): TranslateSentences;
+    getSentenceFromDomSelector(htmlElem: HTMLElement | SVGElement): TranslateSentences;
+}

package/dist/src/translator/keyboard-navigation-translator.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Software Name : UUV
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This software is distributed under the MIT License,
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardNavigationTranslator = void 0;
+const abstract_translator_1 = require("./abstract-translator");
+const model_1 = require("./model");
+const stepCase = model_1.StepCaseEnum.THEN;
+class KeyboardNavigationTranslator extends abstract_translator_1.Translator {
+    getSentenceFromAccessibleRoleAndName(accessibleRole, accessibleName) {
+        const response = this.initResponse();
+        const computedKey = "key.then.element.nextWithRoleAndNameFocused";
+        const sentence = this.computeSentenceFromKeyRoleAndName(computedKey, accessibleRole, accessibleName);
+        response.sentences = [stepCase + sentence];
+        return response;
+    }
+    getSentenceFromAccessibleRoleAndNameAndContent(accessibleRole, accessibleName, content) {
+        return this.getSentenceFromAccessibleRoleAndName(accessibleRole, accessibleName);
+    }
+    getSentenceFromDomSelector(htmlElem) {
+        const response = this.initResponse();
+        const computedKey = "key.then.element.withSelectorFocused";
+        const sentence = this.computeSentenceFromKeyAndSelector(computedKey, abstract_translator_1.Translator.getSelector(htmlElem));
+        const nextFocusedElementSentence = this.dictionary.getBaseSentences().find((el) => el.key === "key.when.keyboard.nextElement");
+        response.sentences = [
+            stepCase + (nextFocusedElementSentence === null || nextFocusedElementSentence === void 0 ? void 0 : nextFocusedElementSentence.wording),
+            model_1.StepCaseEnum.AND + sentence
+        ];
+        return response;
+    }
+}
+exports.KeyboardNavigationTranslator = KeyboardNavigationTranslator;

package/dist/src/translator/model.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Software Name : UUV
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This software is distributed under the MIT License,
+ * 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 declare class Suggestion {
+    accessibleAttribute: string;
+    accessibleValue: string;
+    code: string;
+    sentenceAfterCorrection: string[];
+    constructor(accessibleAttribute?: string, accessibleValue?: string, code?: string, sentenceAfterCorrection?: string[]);
+}
+export type BaseSentence = {
+    key: string;
+    description: string;
+    wording: string;
+};
+export type EnrichedSentence = {
+    key: string;
+    wording: string;
+};
+export declare enum StepCaseEnum {
+    WHEN = "When ",
+    THEN = "Then ",
+    GIVEN = "Given ",
+    AND = "And "
+}
+export type TranslateSentences = {
+    suggestion: Suggestion | undefined;
+    sentences: string[];
+};

package/dist/src/translator/model.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Software Name : UUV
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This software is distributed under the MIT License,
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepCaseEnum = exports.Suggestion = void 0;
+class Suggestion {
+    constructor(accessibleAttribute = "", accessibleValue = "", code = "", sentenceAfterCorrection = []) {
+        this.accessibleAttribute = accessibleAttribute;
+        this.accessibleValue = accessibleValue;
+        this.code = code;
+        this.sentenceAfterCorrection = sentenceAfterCorrection;
+    }
+}
+exports.Suggestion = Suggestion;
+var StepCaseEnum;
+(function (StepCaseEnum) {
+    StepCaseEnum["WHEN"] = "When ";
+    StepCaseEnum["THEN"] = "Then ";
+    StepCaseEnum["GIVEN"] = "Given ";
+    StepCaseEnum["AND"] = "And ";
+})(StepCaseEnum || (exports.StepCaseEnum = StepCaseEnum = {}));

package/dist/src/translator/textual-translator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Software Name : UUV
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This software is distributed under the MIT License,
+ * 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.
+ */
+import { TranslateSentences } from "./model";
+export declare function computeSentence(element: HTMLElement | SVGElement | Element): Promise<TranslateSentences | null>;
+export declare function isTextualNode(element: HTMLElement | SVGElement | Element): boolean;