@uuv/assistant 2.73.0 → 2.73.2

package/dist/src/Commons.d.ts

@@ -0,0 +1,60 @@
+import React from "react";
+export declare const UUV_ASSISTANT_BAR_WIDTH = 60;
+export type ResultSentence = {
+    key: React.Key;
+    result: string;
+};
+export declare class Suggestion {
+    accessibleAttribute: string;
+    accessibleValue: string;
+    code: string;
+    sentenceAfterCorrection: string[];
+    constructor(accessibleAttribute?: string, accessibleValue?: string, code?: string, sentenceAfterCorrection?: string[]);
+}
+export declare enum VisibilityEnum {
+    HIDE = "hide",
+    WITH_RESULT = "withResult",
+    WITHOUT_RESULT = "withoutResult",
+    SETTINGS = "settings"
+}
+export declare enum ActionEnum {
+    NONE = "No action",
+    WITHIN = "Within",
+    EXPECT = "Expect",
+    CLICK = "Click",
+    TYPE = "Type",
+    KEYBOARD_GLOBAL_NAVIGATION = "Keyboard Navigation",
+    FORM_COMPLETION_MOUSE = "Form Mouse Completion",
+    TABLE_AND_GRID_EXPECT = "Table and Grid Expect",
+    DIALOG_EXPECT = "Dialog Expect",
+    FORM_COMPLETION_KEYBOARD = "Form Keyboard Completion",
+    RECORD = "Record"
+}
+export declare enum KeyboardNavigationModeEnum {
+    NONE = "No navigation",
+    CURRENT_NAVIGATION = "currentNavigation",
+    EXPECTED_NAVIGATION = "expectedNavigation"
+}
+export declare enum AdditionalLayerEnum {
+    CURRENT_NAVIGATION = "keyboard-layer-current-navigation",
+    EXPECTED_NAVIGATION = "keyboard-layer-expected-navigation",
+    FORM_COMPLETION = "form-layer-completion",
+    DIALOG_COMPLETION = "dialog-layer-completion",
+    ARRAY_COMPLETION = "array-layer-completion"
+}
+export declare const UUV_DISABLED_CLASS = "uuv-is-disabled";
+export declare const PENDING_VALUE = "pending";
+export type UuvAssistantResultAIAnalysisType = {
+    mode: AIAnalysisModeEnum;
+    available_image_descriptions?: string[] | typeof PENDING_VALUE;
+    onDescriptionSelected?: (selectedImageDescription: string) => void;
+    is_decorative: boolean | typeof PENDING_VALUE;
+    confidence: number | typeof PENDING_VALUE;
+    image_description: string | typeof PENDING_VALUE;
+    analysis_details: string | typeof PENDING_VALUE;
+    duration?: number;
+};
+export declare enum AIAnalysisModeEnum {
+    UNIFIED = 0,
+    STEP_BY_STEP = 1
+}

package/dist/src/Commons.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIAnalysisModeEnum = exports.PENDING_VALUE = exports.UUV_DISABLED_CLASS = exports.AdditionalLayerEnum = exports.KeyboardNavigationModeEnum = exports.ActionEnum = exports.VisibilityEnum = exports.Suggestion = exports.UUV_ASSISTANT_BAR_WIDTH = void 0;
+exports.UUV_ASSISTANT_BAR_WIDTH = 60;
+class Suggestion {
+    constructor(accessibleAttribute = "", accessibleValue = "", code = "", sentenceAfterCorrection = []) {
+        this.accessibleAttribute = accessibleAttribute;
+        this.accessibleValue = accessibleValue;
+        this.code = code;
+        this.sentenceAfterCorrection = sentenceAfterCorrection;
+    }
+}
+exports.Suggestion = Suggestion;
+var VisibilityEnum;
+(function (VisibilityEnum) {
+    VisibilityEnum["HIDE"] = "hide";
+    VisibilityEnum["WITH_RESULT"] = "withResult";
+    VisibilityEnum["WITHOUT_RESULT"] = "withoutResult";
+    VisibilityEnum["SETTINGS"] = "settings";
+})(VisibilityEnum || (exports.VisibilityEnum = VisibilityEnum = {}));
+var ActionEnum;
+(function (ActionEnum) {
+    ActionEnum["NONE"] = "No action";
+    ActionEnum["WITHIN"] = "Within";
+    ActionEnum["EXPECT"] = "Expect";
+    ActionEnum["CLICK"] = "Click";
+    ActionEnum["TYPE"] = "Type";
+    ActionEnum["KEYBOARD_GLOBAL_NAVIGATION"] = "Keyboard Navigation";
+    ActionEnum["FORM_COMPLETION_MOUSE"] = "Form Mouse Completion";
+    ActionEnum["TABLE_AND_GRID_EXPECT"] = "Table and Grid Expect";
+    ActionEnum["DIALOG_EXPECT"] = "Dialog Expect";
+    ActionEnum["FORM_COMPLETION_KEYBOARD"] = "Form Keyboard Completion";
+    ActionEnum["RECORD"] = "Record";
+})(ActionEnum || (exports.ActionEnum = ActionEnum = {}));
+var KeyboardNavigationModeEnum;
+(function (KeyboardNavigationModeEnum) {
+    KeyboardNavigationModeEnum["NONE"] = "No navigation";
+    KeyboardNavigationModeEnum["CURRENT_NAVIGATION"] = "currentNavigation";
+    KeyboardNavigationModeEnum["EXPECTED_NAVIGATION"] = "expectedNavigation";
+})(KeyboardNavigationModeEnum || (exports.KeyboardNavigationModeEnum = KeyboardNavigationModeEnum = {}));
+var AdditionalLayerEnum;
+(function (AdditionalLayerEnum) {
+    AdditionalLayerEnum["CURRENT_NAVIGATION"] = "keyboard-layer-current-navigation";
+    AdditionalLayerEnum["EXPECTED_NAVIGATION"] = "keyboard-layer-expected-navigation";
+    AdditionalLayerEnum["FORM_COMPLETION"] = "form-layer-completion";
+    AdditionalLayerEnum["DIALOG_COMPLETION"] = "dialog-layer-completion";
+    AdditionalLayerEnum["ARRAY_COMPLETION"] = "array-layer-completion";
+})(AdditionalLayerEnum || (exports.AdditionalLayerEnum = AdditionalLayerEnum = {}));
+exports.UUV_DISABLED_CLASS = "uuv-is-disabled";
+exports.PENDING_VALUE = "pending";
+var AIAnalysisModeEnum;
+(function (AIAnalysisModeEnum) {
+    AIAnalysisModeEnum[AIAnalysisModeEnum["UNIFIED"] = 0] = "UNIFIED";
+    AIAnalysisModeEnum[AIAnalysisModeEnum["STEP_BY_STEP"] = 1] = "STEP_BY_STEP";
+})(AIAnalysisModeEnum || (exports.AIAnalysisModeEnum = AIAnalysisModeEnum = {}));

package/dist/src/helper/css-helper.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 interface HtmlElementProps {
+    color?: string;
+    background?: string;
+    url?: string;
+    shadow?: string;
+    rotate?: number;
+}
+export declare enum MimeTypeEnum {
+    IMAGE_BMP = "image/bmp",
+    TEXT_CSS = "text/css",
+    TEXT_CSV = "text/csv",
+    IMAGE_GIF = "image/gif",
+    TEXT_HTML = "text/html",
+    IMAGE_X_ICON = "image/x-icon",
+    IMAGE_JPEG = "image/jpeg",
+    APPLICATION_JAVASCRIPT = "application/javascript",
+    APPLICATION_JSON = "application/json",
+    IMAGE_PNG = "image/png",
+    APPLICATION_PDF = "application/pdf",
+    APPLICATION_RTF = "application/rtf",
+    IMAGE_SVG_XML = "image/svg+xml",
+    APPLICATION_TYPESCRIPT = "application/typescript",
+    IMAGE_WEBP = "image/webp",
+    FONT_WOFF = "font/woff",
+    FONT_WOFF2 = "font/woff2",
+    APPLICATION_XHTML_XML = "application/xhtml+xml",
+    APPLICATION_XML = "application/xml",
+    APPLICATION_ZIP = "application/zip"
+}
+export declare class CssHelper {
+    static buttonConfig: (isDark: boolean) => HtmlElementProps;
+    static expanderConfig: (isDark: boolean, isExtended: boolean) => HtmlElementProps;
+    static getBase64File(file: any): string;
+    static iconConfig: (isDark: boolean) => HtmlElementProps;
+}

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

@@ -0,0 +1,83 @@
+"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.CssHelper = exports.MimeTypeEnum = void 0;
+const antd_1 = require("antd");
+var MimeTypeEnum;
+(function (MimeTypeEnum) {
+    MimeTypeEnum["IMAGE_BMP"] = "image/bmp";
+    MimeTypeEnum["TEXT_CSS"] = "text/css";
+    MimeTypeEnum["TEXT_CSV"] = "text/csv";
+    MimeTypeEnum["IMAGE_GIF"] = "image/gif";
+    MimeTypeEnum["TEXT_HTML"] = "text/html";
+    MimeTypeEnum["IMAGE_X_ICON"] = "image/x-icon";
+    MimeTypeEnum["IMAGE_JPEG"] = "image/jpeg";
+    MimeTypeEnum["APPLICATION_JAVASCRIPT"] = "application/javascript";
+    MimeTypeEnum["APPLICATION_JSON"] = "application/json";
+    MimeTypeEnum["IMAGE_PNG"] = "image/png";
+    MimeTypeEnum["APPLICATION_PDF"] = "application/pdf";
+    MimeTypeEnum["APPLICATION_RTF"] = "application/rtf";
+    MimeTypeEnum["IMAGE_SVG_XML"] = "image/svg+xml";
+    MimeTypeEnum["APPLICATION_TYPESCRIPT"] = "application/typescript";
+    MimeTypeEnum["IMAGE_WEBP"] = "image/webp";
+    MimeTypeEnum["FONT_WOFF"] = "font/woff";
+    MimeTypeEnum["FONT_WOFF2"] = "font/woff2";
+    MimeTypeEnum["APPLICATION_XHTML_XML"] = "application/xhtml+xml";
+    MimeTypeEnum["APPLICATION_XML"] = "application/xml";
+    MimeTypeEnum["APPLICATION_ZIP"] = "application/zip";
+})(MimeTypeEnum || (exports.MimeTypeEnum = MimeTypeEnum = {}));
+class CssHelper {
+    /* eslint-disable  @typescript-eslint/no-explicit-any */
+    static getBase64File(file) {
+        if (!Object.values(MimeTypeEnum).includes(file.mime)) {
+            antd_1.notification.error({
+                message: "Error",
+                description: `The mimetype '${file.mime}' of resource is not configured`
+            });
+        }
+        return `data:${file.mime};base64,${file.data}`;
+    }
+}
+exports.CssHelper = CssHelper;
+CssHelper.buttonConfig = (isDark) => {
+    return isDark ? {
+        background: "#0b4c89",
+        color: "#FFF"
+    } : {
+        background: "#d6e4ff",
+        color: "#000"
+    };
+};
+CssHelper.expanderConfig = (isDark, isExtended) => {
+    return isDark ? {
+        background: "#0b4c89",
+        shadow: "rgba(250, 250, 250, 0.16) 0px 10px 36px 0px, rgba(250, 250, 250, 0.06) 0px 0px 0px 1px",
+        rotate: isExtended ? 180 : 0,
+        color: "white"
+    } : {
+        background: "#d6e4ff",
+        shadow: "rgba(0, 0, 0, 0.16) 0px 10px 36px 0px, rgba(0, 0, 0, 0.06) 0px 0px 0px 1px",
+        rotate: isExtended ? 180 : 0,
+        color: "black"
+    };
+};
+CssHelper.iconConfig = (isDark) => {
+    return isDark ? {
+        background: "rgb(31, 31, 31)",
+        color: "#FFF"
+    } : {
+        color: "#000",
+        background: "#FFF",
+    };
+};

package/dist/src/helper/highlight/highlight-helper.d.ts

@@ -0,0 +1,13 @@
+export declare const HIGHLIGHT_ORANGE_PROPS: {
+    width: number;
+    borderColor: string;
+};
+export declare class HighlightHelper {
+    private onSelect;
+    private inspector;
+    constructor(onSelect: (el: HTMLElement) => void);
+    private createInspector;
+    enableBasicHighlight(): void;
+    enableRefinedHighlight(): void;
+    cancel(): void;
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HighlightHelper = exports.HIGHLIGHT_ORANGE_PROPS = void 0;
+const inspector_dom_1 = __importDefault(require("./inspector-dom"));
+const informative_nodes_helper_1 = require("../informative-nodes-helper");
+exports.HIGHLIGHT_ORANGE_PROPS = {
+    width: 4,
+    borderColor: "orange"
+};
+class HighlightHelper {
+    constructor(onSelect) {
+        this.onSelect = onSelect;
+    }
+    createInspector(onMouseOver, onMouseOut) {
+        this.inspector = (0, inspector_dom_1.default)({
+            root: "body",
+            outlineStyle: "2px solid red",
+            onClick: (el) => {
+                this.onSelect(el);
+                this.inspector.cancel();
+            },
+            onMouseOver,
+            onMouseOut
+        });
+    }
+    enableBasicHighlight() {
+        this.createInspector(el => this.inspector.highlight(el), el => this.inspector.removeHighlight(el));
+        this.inspector.enable();
+    }
+    enableRefinedHighlight() {
+        const informativeNodesHelper = new informative_nodes_helper_1.InformativeNodesHelper();
+        const nodesWithInfo = informativeNodesHelper.getAvailableNodes();
+        this.createInspector(el => {
+            if (nodesWithInfo.includes(el)) {
+                this.inspector.highlight(el);
+            }
+        }, el => {
+            if (nodesWithInfo.includes(el)) {
+                this.inspector.removeHighlight(el);
+            }
+        });
+        this.inspector.enable();
+    }
+    cancel() {
+        this.inspector.cancel();
+    }
+}
+exports.HighlightHelper = HighlightHelper;

package/dist/src/helper/highlight/inspector-dom.d.ts

@@ -0,0 +1,7 @@
+export default Inspector;
+declare function Inspector(props?: {}): {
+    enable: (onClickCallback: any) => void;
+    cancel: () => void;
+    removeHighlight: (el: any) => void;
+    highlight: (el: any) => void;
+};

package/dist/src/helper/highlight/inspector-dom.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dom_accessibility_api_1 = require("dom-accessibility-api");
+const tooltip_helper_1 = require("./tooltip-helper");
+const abstract_translator_1 = require("../../translator/abstract-translator");
+const VALID_CLASSNAME = /^[_a-zA-Z\- ]*$/;
+var defaultProps = {
+    root: "body",
+    outlineStyle: "5px solid rgba(204, 146, 62, 0.3)",
+    onClick: (el) => console.log("Element was clicked:", abstract_translator_1.Translator.getSelector(el)),
+};
+var Inspector = (props = {}) => {
+    // @ts-ignore
+    const { root, excluded, outlineStyle } = Object.assign(Object.assign({}, defaultProps), props);
+    let onClick = props.onClick || defaultProps.onClick;
+    let onMouseOver = props.onMouseOver;
+    let onMouseOut = props.onMouseOut;
+    let selected, excludedElements, activeOverlay;
+    const highlight = (el) => {
+        el.style.outline = outlineStyle;
+        el.style.outlineOffset = `-${el.style.outlineWidth}`;
+        if (activeOverlay) {
+            removeHighlightOverlay(activeOverlay);
+        }
+        activeOverlay = applyHighlightOverlay(el);
+        const name = (0, dom_accessibility_api_1.computeAccessibleName)(el);
+        const role = (0, dom_accessibility_api_1.getRole)(el);
+        const content = [];
+        let state;
+        if (name && role) {
+            content.push("✅ Good");
+            state = "good";
+        }
+        else if (name || role) {
+            content.push("⚠️ Warning");
+            state = "warning";
+        }
+        else {
+            content.push("❌ Danger");
+            state = "danger";
+        }
+        const selector = `<label><b>Selector: </b></label><span style="text-wrap: wrap">${abstract_translator_1.Translator.getSelector(el)}</span>`;
+        const tagName = `<label><b>Tag name: </b></label><span>${el.tagName.toLowerCase()}</span>`;
+        const type = el.type ? `<div><label><b>Type: </b></label><span>${el.type}</span></div>` : "";
+        content.push(`<p><div>${tagName}</div><div>${type}</div><div>${selector}</div></p>`);
+        content.push(`<div><div><label><b>Name: </b></label><span>${name}</span></div><div><label><b>Role: </b></label><span>${role || ""}</span></div></div>`);
+        (0, tooltip_helper_1.showTooltip)(el, content.join("<hr style='opacity: 0.3' />"), state);
+    };
+    const removeHighlight = (el) => {
+        if (el) {
+            el.style.outline = "none";
+            if (activeOverlay) {
+                removeHighlightOverlay(activeOverlay);
+                activeOverlay = null;
+            }
+        }
+        (0, tooltip_helper_1.removeTooltip)();
+    };
+    // @ts-ignore
+    const shouldBeExcluded = (ev) => {
+        if (excludedElements &&
+            excludedElements.length &&
+            excludedElements.some((parent) => parent === ev.target || parent.contains(ev.target))) {
+            return true;
+        }
+    };
+    let handleMouseOver = (ev) => {
+        if (shouldBeExcluded(ev)) {
+            return;
+        }
+        selected = ev.target;
+        onMouseOver(ev.target);
+    };
+    let handleMouseOut = (ev) => {
+        if (shouldBeExcluded(ev)) {
+            return;
+        }
+        onMouseOut(ev.target);
+    };
+    const handleClick = (ev) => {
+        if (shouldBeExcluded(ev)) {
+            return;
+        }
+        ev.preventDefault();
+        ev.stopPropagation();
+        onClick(ev.target);
+        return false;
+    };
+    const prepareExcluded = (rootEl) => {
+        if (!excluded.length) {
+            return [];
+        }
+        // @ts-ignore
+        const excludedNested = excluded.flatMap((element) => {
+            if (typeof element === "string" || element instanceof String) {
+                return Array.from(rootEl.querySelectorAll(element));
+            }
+            else if (element instanceof Element) {
+                return [element];
+            }
+            else if (element.length > 0 && element[0] instanceof Element) {
+                return Array.from(element);
+            }
+        });
+        return Array.from(excludedNested).flat();
+    };
+    const enable = (onClickCallback) => {
+        const rootEl = document.querySelector(root);
+        if (!rootEl) {
+            return;
+        }
+        if (excluded) {
+            excludedElements = prepareExcluded(rootEl);
+        }
+        rootEl.addEventListener("mouseover", handleMouseOver, true);
+        rootEl.addEventListener("mouseout", handleMouseOut, true);
+        rootEl.addEventListener("click", handleClick, true);
+        if (onClickCallback) {
+            onClick = onClickCallback;
+        }
+    };
+    const cancel = () => {
+        const rootEl = document.querySelector(root);
+        if (!rootEl) {
+            return;
+        }
+        rootEl.removeEventListener("mouseover", handleMouseOver, true);
+        rootEl.removeEventListener("mouseout", handleMouseOut, true);
+        rootEl.removeEventListener("click", handleClick, true);
+        removeHighlight(selected);
+    };
+    return {
+        enable,
+        cancel,
+        removeHighlight,
+        highlight,
+    };
+};
+function applyHighlightOverlay(target) {
+    const rect = target.getBoundingClientRect();
+    const overlay = document.createElement("div");
+    overlay.style.position = "absolute";
+    overlay.style.top = `${rect.top + window.scrollY}px`;
+    overlay.style.left = `${rect.left + window.scrollX}px`;
+    overlay.style.width = `${rect.width}px`;
+    overlay.style.height = `${rect.height}px`;
+    overlay.style.background = "rgba(255, 0, 0, 0.05)";
+    overlay.style.pointerEvents = "none";
+    overlay.style.zIndex = "9999998";
+    document.body.appendChild(overlay);
+    return overlay;
+}
+function removeHighlightOverlay(overlay) {
+    if (overlay) {
+        overlay.remove();
+    }
+}
+exports.default = Inspector;

package/dist/src/helper/highlight/tooltip-helper.d.ts

@@ -0,0 +1,2 @@
+export function showTooltip(el: any, content: any, state: any): void;
+export function removeTooltip(): void;

package/dist/src/helper/highlight/tooltip-helper.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showTooltip = showTooltip;
+exports.removeTooltip = removeTooltip;
+let tooltipEl = null;
+function showTooltip(el, content, state) {
+    removeTooltip();
+    tooltipEl = document.createElement("div");
+    tooltipEl.className = "tooltip-highlight";
+    tooltipEl.innerHTML = content;
+    tooltipEl.style.position = "absolute";
+    tooltipEl.style.border = "2px solid black";
+    switch (state) {
+        case "good":
+            tooltipEl.style.background = "rgba(23,62,23,0.85)";
+            tooltipEl.style.border = "2px solid rgb(23,62,23)";
+            break;
+        case "warning":
+            tooltipEl.style.background = "rgba(87,65,18,0.85)";
+            tooltipEl.style.border = "2px solid rgb(87,65,18)";
+            break;
+        case "danger":
+            tooltipEl.style.background = "rgba(78,11,11,0.85)";
+            tooltipEl.style.border = "2px solid rgb(78,11,11)";
+            break;
+        default:
+            tooltipEl.style.background = "rgba(0,0,0, 0.85)";
+            tooltipEl.style.border = "2px solid black";
+    }
+    tooltipEl.style.color = "#fff";
+    tooltipEl.style.padding = "6px 10px";
+    tooltipEl.style.borderRadius = "4px";
+    tooltipEl.style.fontSize = "14px";
+    tooltipEl.style.zIndex = "9999999";
+    tooltipEl.style.whiteSpace = "nowrap";
+    tooltipEl.style.boxShadow = "0 0 6px rgba(0,0,0,0.2)";
+    tooltipEl.style.pointerEvents = "none";
+    tooltipEl.style.transition = "opacity 0.2s";
+    tooltipEl.style.width = "300px";
+    tooltipEl.style.maxWidth = "300px";
+    document.body.appendChild(tooltipEl);
+    positionTooltip(el);
+}
+function removeTooltip() {
+    if (tooltipEl) {
+        tooltipEl.remove();
+        tooltipEl = null;
+    }
+}
+function positionTooltip(targetElement) {
+    const elRect = targetElement.getBoundingClientRect();
+    const tooltipRect = tooltipEl.getBoundingClientRect();
+    let y = elRect.top + window.scrollY - tooltipRect.height; // Above
+    let x = elRect.left + window.scrollX + (elRect.width - tooltipRect.width) / 2;
+    if (y < window.scrollY) {
+        y = elRect.bottom + window.scrollY;
+    }
+    if (x < 8) {
+        x = 8;
+    }
+    const maxLeft = window.scrollX + document.documentElement.clientWidth - tooltipRect.width;
+    if (x > maxLeft) {
+        x = maxLeft;
+    }
+    tooltipEl.style.left = `${x}px`;
+    tooltipEl.style.top = `${y}px`;
+}

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

@@ -0,0 +1 @@
+export * from "./result-script-helper";

package/dist/src/helper/index.js

@@ -0,0 +1,17 @@
+"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("./result-script-helper"), exports);

package/dist/src/helper/informative-nodes-helper.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 InformativeNodesHelper {
+    private readonly TAGS_WITH_NATIVE_ACCESSIBILITY_DATA;
+    private readonly INTERESTING_TAGS;
+    private readonly candidatesWithNativeAccessibleData;
+    private readonly candidatesWithCustomAccessibleData;
+    constructor();
+    /**
+     * Trouve l'élément parent le plus pertinent pour l'analyse d'accessibilité
+     * @param {HTMLElement} element - L'élément de départ
+     * @returns {HTMLElement|null} - L'élément parent pertinent ou null si non trouvé
+     */
+    findRelevantAccessibilityParent(element: any): HTMLElement | null;
+    extractContextForElement(element: Element): {
+        parentElement: HTMLElement | null;
+        htmlContext: string;
+        siblingText: string;
+    };
+    getSiblingsFragment(element: Element, maxSiblings?: number): string;
+    private extractInterestingChildren;
+    private isStructuralOnly;
+    private findInformativeElements;
+    getAvailableNodes(): Element[];
+    getAvailableChildren(node: HTMLElement | Element): Promise<Element[]>;
+    private hasInformativeAttributes;
+    getDialogName(node: Element): string | null;
+}