@uuv/assistant 2.73.0 → 2.73.1

package/dist/src/helper/selection-helper.js

@@ -0,0 +1,92 @@
+"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.SelectionHelper = void 0;
+const Commons_1 = require("../Commons");
+const click_translator_1 = require("../translator/click-translator");
+const expect_translator_1 = require("../translator/expect-translator");
+const within_translator_1 = require("../translator/within-translator");
+const type_translator_1 = require("../translator/type-translator");
+const highlight_helper_1 = require("./highlight/highlight-helper");
+class SelectionHelper {
+    constructor(onSelect, onReset, intelligentHighlight) {
+        this.onKeyDown = (e) => {
+            if (e.key === "Escape") {
+                this.onReset();
+                this.highLightHelper.cancel();
+                this.revertDisabledField();
+                document.removeEventListener("keydown", this.onKeyDown);
+            }
+        };
+        this.highLightHelper = new highlight_helper_1.HighlightHelper(onSelect);
+        this.onReset = onReset;
+        this.intelligentHighlight = intelligentHighlight;
+    }
+    startSelect(enableDisabledField) {
+        if (enableDisabledField) {
+            this.enableDisabledField();
+        }
+        document.addEventListener("keydown", this.onKeyDown);
+        if (this.intelligentHighlight) {
+            this.highLightHelper.enableRefinedHighlight();
+        }
+        else {
+            this.highLightHelper.enableBasicHighlight();
+        }
+    }
+    buildResultSentence(el, action, isDisabled) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let translator;
+            switch (action) {
+                case Commons_1.ActionEnum.WITHIN:
+                    translator = new within_translator_1.WithinTranslator();
+                    break;
+                case Commons_1.ActionEnum.EXPECT:
+                    translator = new expect_translator_1.ExpectTranslator();
+                    break;
+                case Commons_1.ActionEnum.CLICK:
+                    translator = new click_translator_1.ClickTranslator();
+                    break;
+                case Commons_1.ActionEnum.TYPE:
+                    translator = new type_translator_1.TypeTranslator();
+                    break;
+            }
+            return translator.translate(el);
+        });
+    }
+    enableDisabledField() {
+        const disabledElement = document.querySelectorAll(":disabled");
+        disabledElement.forEach((elem) => {
+            elem.className = `${elem.className} ${Commons_1.UUV_DISABLED_CLASS}`;
+            elem.removeAttribute("disabled");
+        });
+    }
+    revertDisabledField() {
+        const disabledElement = document.querySelectorAll(`.${Commons_1.UUV_DISABLED_CLASS}`);
+        disabledElement.forEach((elem) => {
+            elem.className = elem.className.replaceAll(Commons_1.UUV_DISABLED_CLASS, "");
+            elem.setAttribute("disabled", "true");
+        });
+    }
+}
+exports.SelectionHelper = SelectionHelper;

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./translator";
+export * from "./service";
+export * from "./helper";

package/dist/src/index.js

@@ -0,0 +1,19 @@
+"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("./translator"), exports);
+__exportStar(require("./service"), exports);
+__exportStar(require("./helper"), exports);

package/dist/src/service/abstract-component-service.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 { AdditionalLayerEnum } from "../Commons";
+import { ExpectTranslator } from "../translator/expect-translator";
+export declare abstract class AbstractComponentService {
+    expectTranslator: ExpectTranslator;
+    private buildAdditionalStyle;
+    addListener(dom: ShadowRoot, elements: HTMLElement[], onSelect: (el: HTMLElement) => void, onReset: () => void): void;
+    show(dom: ShadowRoot, layer: AdditionalLayerEnum, htmlElements: HTMLElement[], onSelect: (el: HTMLElement) => void, onReset: () => void): void;
+    abstract buildResultSentence(selectedArray: HTMLElement): Promise<string[]>;
+}

package/dist/src/service/abstract-component-service.js

@@ -0,0 +1,107 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractComponentService = void 0;
+const LayerHelper = __importStar(require("../helper/layer-helper"));
+const highlight_helper_1 = require("../helper/highlight/highlight-helper");
+const expect_translator_1 = require("../translator/expect-translator");
+class AbstractComponentService {
+    constructor() {
+        this.expectTranslator = new expect_translator_1.ExpectTranslator();
+    }
+    buildAdditionalStyle(elements) {
+        let completeStyle = "";
+        if (elements) {
+            elements.forEach((element, index) => {
+                completeStyle = `${completeStyle}
+      
+      .element-border {
+        stroke-width: ${highlight_helper_1.HIGHLIGHT_ORANGE_PROPS.width};
+        stroke: ${highlight_helper_1.HIGHLIGHT_ORANGE_PROPS.borderColor};
+        fill-opacity: 10%;
+        fill: black;
+        cursor: pointer;
+      }
+      
+      .element-border:hover {
+        fill: red;
+      }
+      `;
+            });
+        }
+        return completeStyle;
+    }
+    addListener(dom, elements, onSelect, onReset) {
+        if (elements) {
+            elements.forEach((element, index) => {
+                const targetElement = dom.getElementById(`element-border-${index}`);
+                if (targetElement) {
+                    const functionToTrigger = () => {
+                        onSelect(element);
+                    };
+                    targetElement.addEventListener("click", functionToTrigger);
+                }
+            });
+            const escapeFunction = (e) => {
+                if (e.key === "Escape") {
+                    onReset();
+                    document.removeEventListener("keydown", escapeFunction);
+                }
+            };
+            document.addEventListener("keydown", escapeFunction);
+        }
+    }
+    show(dom, layer, htmlElements, onSelect, onReset) {
+        const customLayer = document.createElement("div");
+        customLayer.setAttribute("id", layer.toString());
+        customLayer.setAttribute("class", "uvv-assistant-additional-layer");
+        dom.appendChild(customLayer);
+        LayerHelper.buildLayer(dom, layer, htmlElements, this.buildAdditionalStyle(htmlElements), true, false);
+        this.addListener(dom, htmlElements, onSelect, onReset);
+    }
+}
+exports.AbstractComponentService = AbstractComponentService;

package/dist/src/service/dialog-service.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 { AdditionalLayerEnum } from "../Commons";
+import { AbstractComponentService } from "./abstract-component-service";
+export declare class DialogService extends AbstractComponentService {
+    TRACKED_CLASS: string;
+    show(dom: ShadowRoot, layer: AdditionalLayerEnum, elements: HTMLElement[], onSelect: (el: HTMLElement) => void, onReset: () => void): void;
+    private overrideStyles;
+    private computeTopPosition;
+    private clone;
+    buildResultSentence(selectedArray: HTMLElement): Promise<string[]>;
+}

package/dist/src/service/dialog-service.js

@@ -0,0 +1,90 @@
+"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.DialogService = void 0;
+const informative_nodes_helper_1 = require("../helper/informative-nodes-helper");
+const abstract_component_service_1 = require("./abstract-component-service");
+class DialogService extends abstract_component_service_1.AbstractComponentService {
+    constructor() {
+        super(...arguments);
+        this.TRACKED_CLASS = "uuv-dialog-clone";
+    }
+    show(dom, layer, elements, onSelect, onReset) {
+        const clones = [];
+        let currentTop = 0;
+        elements.forEach((dialog, index) => {
+            const clone = document.createElement("div");
+            this.clone(clone, dialog);
+            this.overrideStyles(currentTop, dialog, clone);
+            const onClick = () => {
+                onSelect(clone);
+                clone.removeEventListener("click", onClick);
+                document.body.removeChild(clone);
+                Array.from(document.getElementsByClassName(this.TRACKED_CLASS)).forEach(el => el.remove());
+            };
+            clone.addEventListener("click", onClick);
+            document.body.appendChild(clone);
+            clones.push(clone);
+        });
+        super.show(dom, layer, clones, onSelect, onReset);
+    }
+    overrideStyles(currentTop, dialog, clone) {
+        currentTop = this.computeTopPosition(dialog, currentTop);
+        clone.classList.add(this.TRACKED_CLASS);
+        clone.style.position = "fixed";
+        clone.style.top = `${currentTop}px`;
+        clone.style.left = "2rem";
+        clone.style.right = "2rem";
+        clone.style.zIndex = "9999";
+        clone.style.display = "block";
+    }
+    computeTopPosition(dialog, currentTop) {
+        const style = getComputedStyle(dialog);
+        const marginBottom = parseFloat(style.marginBottom) || 0;
+        const marginTop = parseFloat(style.marginTop) || 0;
+        const height = dialog.getBoundingClientRect().height + marginTop + marginBottom;
+        currentTop += height + 30;
+        return currentTop;
+    }
+    clone(clone, dialog) {
+        clone.innerHTML = dialog.innerHTML;
+        const styles = getComputedStyle(dialog);
+        for (let i = 0; i < styles.length; i++) {
+            const prop = styles[i];
+            clone.style.setProperty(prop, styles.getPropertyValue(prop));
+        }
+        for (let i = 0; i < dialog.attributes.length; i++) {
+            const attr = dialog.attributes[i];
+            clone.setAttribute(attr.name, attr.value);
+        }
+    }
+    buildResultSentence(selectedArray) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const name = (_a = new informative_nodes_helper_1.InformativeNodesHelper().getDialogName(selectedArray)) !== null && _a !== void 0 ? _a : "";
+            const sentenceKey = "key.when.withinElement.roleAndName";
+            return this.expectTranslator.computeDialogSentenceFromKeyNameAndContent(sentenceKey, name, selectedArray);
+        });
+    }
+}
+exports.DialogService = DialogService;

package/dist/src/service/form-completion-service.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 { FocusableElement } from "tabbable";
+import { AbstractComponentService } from "./abstract-component-service";
+export declare class FormCompletionService extends AbstractComponentService {
+    private typeTranslator;
+    private clickTranslator;
+    buildResultSentence(selectedForm: HTMLElement): Promise<string[]>;
+    isButton(element: FocusableElement): boolean;
+    isSubmitButton(element: FocusableElement): boolean;
+    isDisabled(element: FocusableElement): boolean;
+    isHidden(element: FocusableElement): boolean;
+}

package/dist/src/service/form-completion-service.js

@@ -0,0 +1,72 @@
+"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.FormCompletionService = void 0;
+const type_translator_1 = require("../translator/type-translator");
+const click_translator_1 = require("../translator/click-translator");
+const dom_accessibility_api_1 = require("dom-accessibility-api");
+const abstract_component_service_1 = require("./abstract-component-service");
+class FormCompletionService extends abstract_component_service_1.AbstractComponentService {
+    constructor() {
+        super(...arguments);
+        this.typeTranslator = new type_translator_1.TypeTranslator();
+        this.clickTranslator = new click_translator_1.ClickTranslator();
+    }
+    buildResultSentence(selectedForm) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const elementsForCompletion = [].slice.call(selectedForm.getElementsByTagName("input"));
+            elementsForCompletion.push(...[].slice.call(selectedForm.getElementsByTagName("button")));
+            const sentences = [];
+            let foundSubmitButton = false;
+            const promises = elementsForCompletion
+                .filter(element => !this.isDisabled(element) && !this.isHidden(element))
+                .map((formElement) => __awaiter(this, void 0, void 0, function* () {
+                if (!this.isButton(formElement) || (this.isSubmitButton(formElement) && !foundSubmitButton)) {
+                    let translator = this.typeTranslator;
+                    if (this.isSubmitButton(formElement)) {
+                        translator = this.clickTranslator;
+                        foundSubmitButton = true;
+                    }
+                    const result = yield translator.translate(formElement);
+                    sentences.push(...result.sentences);
+                }
+                return Promise.resolve("");
+            }));
+            yield Promise.all(promises);
+            return sentences;
+        });
+    }
+    isButton(element) {
+        return (0, dom_accessibility_api_1.getRole)(element) === "button";
+    }
+    isSubmitButton(element) {
+        return this.isButton(element) && element.getAttribute("type") === "submit";
+    }
+    isDisabled(element) {
+        return element.disabled;
+    }
+    isHidden(element) {
+        return element.type === "hidden";
+    }
+}
+exports.FormCompletionService = FormCompletionService;

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

@@ -0,0 +1,4 @@
+export * from "./abstract-component-service";
+export * from "./dialog-service";
+export * from "./form-completion-service";
+export * from "./table-and-grid-service";

package/dist/src/service/index.js

@@ -0,0 +1,20 @@
+"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("./abstract-component-service"), exports);
+__exportStar(require("./dialog-service"), exports);
+__exportStar(require("./form-completion-service"), exports);
+__exportStar(require("./table-and-grid-service"), exports);

package/dist/src/service/table-and-grid-service.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 { AbstractComponentService } from "./abstract-component-service";
+export declare class TableAndGridService extends AbstractComponentService {
+    buildResultSentence(selectedArray: HTMLTableElement | HTMLElement): Promise<string[]>;
+    private extractHeaderAndDataRows;
+}

package/dist/src/service/table-and-grid-service.js

@@ -0,0 +1,87 @@
+"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.TableAndGridService = void 0;
+const dom_accessibility_api_1 = require("dom-accessibility-api");
+const abstract_component_service_1 = require("./abstract-component-service");
+class TableAndGridService extends abstract_component_service_1.AbstractComponentService {
+    buildResultSentence(selectedArray) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const sentences = [];
+            const tableName = (0, dom_accessibility_api_1.computeAccessibleName)(selectedArray);
+            let headers;
+            const indefiniteArticle = "a";
+            let roleName;
+            let values;
+            let cellRoleName;
+            const sentenceKey = "key.then.element.withRoleAndNameAndContent";
+            const role = (_a = (0, dom_accessibility_api_1.getRole)(selectedArray)) !== null && _a !== void 0 ? _a : "";
+            switch (role) {
+                case "table": {
+                    const headerAndDataRows = this.extractHeaderAndDataRows(selectedArray);
+                    headers = headerAndDataRows.headers;
+                    values = headerAndDataRows.values;
+                    roleName = "table";
+                    cellRoleName = "cell";
+                    break;
+                }
+                case "grid": {
+                    const headerAndDataRows = this.extractHeaderAndDataRows(selectedArray);
+                    headers = headerAndDataRows.headers;
+                    values = headerAndDataRows.values;
+                    roleName = "grid";
+                    cellRoleName = "gridcell";
+                    break;
+                }
+                case "treegrid": {
+                    const headerAndDataRows = this.extractHeaderAndDataRows(selectedArray);
+                    headers = headerAndDataRows.headers;
+                    values = headerAndDataRows.values;
+                    roleName = "treegrid";
+                    cellRoleName = "gridcell";
+                    break;
+                }
+            }
+            const result = this.expectTranslator.computeTableSentenceFromKeyNameAndContent(sentenceKey, indefiniteArticle, roleName, tableName, headers, values, cellRoleName);
+            sentences.push(result);
+            return sentences;
+        });
+    }
+    extractHeaderAndDataRows(selectedArray) {
+        const rows = Array.from(selectedArray.querySelectorAll('[role=row], tr'));
+        if (rows.length > 0) {
+            return {
+                headers: rows[0],
+                values: rows.slice(1)
+            };
+        }
+        else {
+            return {
+                headers: [],
+                values: []
+            };
+        }
+    }
+}
+exports.TableAndGridService = TableAndGridService;

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;
+}