@uuv/dictionary 0.0.1

package/.eslintignore

@@ -0,0 +1,2 @@
+node_modules
+dist

package/.eslintrc.js

@@ -0,0 +1,100 @@
+module.exports = {
+    "env": {
+        "browser": true,
+        "es2021": true
+    },
+    "extends": [
+        "../../.eslintrc.json",
+        "eslint:recommended",
+        "plugin:@nx/typescript"
+    ],
+    "overrides": [
+    ],
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "ecmaVersion": "latest",
+        "sourceType": "module"
+    },
+    "plugins": [
+        "jest"
+    ],
+    "rules": {
+        "no-negated-in-lhs": "error",
+        "no-cond-assign": ["error", "except-parens"],
+        "curly": ["error", "all"],
+        "object-curly-spacing": ["error", "always"],
+        "no-unused-expressions": "error",
+        "no-sequences": "error",
+        "no-nested-ternary": "error",
+        "no-unreachable": "error",
+        "wrap-iife": ["error", "inside"],
+        "no-caller": "error",
+        "quotes": ["error", "double"],
+        "no-undef": "off",
+        "no-unused-vars": "off",
+        "comma-style": ["error", "last"],
+        "camelcase": [
+            "error",
+            {
+                "properties": "never"
+            }
+        ],
+        "dot-notation": [
+            "error",
+            {
+                "allowPattern": "^[a-z]+(_[a-z]+)+$"
+            }
+        ],
+        "max-len": [
+            "warn",
+            {
+                "code": 150,
+                "ignoreComments": true,
+                "ignoreUrls": true,
+                "ignoreRegExpLiterals": true
+            }
+        ],
+        "no-mixed-spaces-and-tabs": "error",
+        "no-trailing-spaces": "error",
+        "no-multi-str": "error",
+        "comma-spacing": [
+            "error",
+            {
+                "before": false,
+                "after": true
+            }
+        ],
+        "space-before-blocks": ["error", "always"],
+        "space-in-parens": ["off"],
+        "keyword-spacing": [2],
+        "semi": ["error", "always"],
+        "semi-spacing": [
+            "error",
+            {
+                "after": true
+            }
+        ],
+        "space-infix-ops": "error",
+        "eol-last": "error",
+        "linebreak-style": ["error", process.platform === "win32" ? "windows" : "unix"],
+        "no-with": "error",
+        "brace-style": "error",
+        "space-before-function-paren": ["off"],
+        "no-loop-func": "error",
+        "key-spacing": [
+            "error",
+            {
+                "beforeColon": false,
+                "afterColon": true
+            }
+        ],
+        "space-unary-ops": [
+            "error",
+            {
+                "words": false,
+                "nonwords": false
+            }
+        ],
+        "no-multiple-empty-lines": 2
+    }
+};

package/LICENSE

@@ -0,0 +1,22 @@
+
+
+                                    MIT License
+
+        Permission is hereby granted, free of charge, to any person obtaining a copy of
+        this software and associated documentation files (the "Software"), to deal in
+        the Software without restriction, including without limitation the rights to use,
+        copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+        Software, and to permit persons to whom the Software is furnished to do so,
+        subject to the following conditions:
+
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+        OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+        NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+        HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+        WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+        FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+        OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,57 @@
+# @uuv/dictionary
+
+[![npm version](https://badge.fury.io/js/%40uuv%2Fdictionary.svg)](https://badge.fury.io/js/%40uuv%2Fdictionary)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+This package provides a built-in set of Cucumber sentences for writing end-to-end tests with UUV. It includes translations in English and French, along with accessibility role-based sentence generation.
+
+## Features
+
+- Built-in Cucumber sentences for E2E testing
+- Support for multiple languages (English and French)
+- Role-based sentence generation for accessibility
+- Integration-ready with Cypress, Playwright, and Testing Library
+
+## Installation
+
+```bash
+npm install @uuv/dictionary
+```
+
+## Usage
+
+Import the dictionary in your test files:
+
+```typescript
+import { getDefinedDictionary } from '@uuv/dictionary';
+
+const dictionary = getDefinedDictionary('en'); // or 'fr' for French
+```
+
+### Available Dictionaries
+
+- English (`en`)
+- French (`fr`)
+
+## Structure
+
+The package contains:
+
+1. **Base Sentences**: General sentences for common actions
+2. **Role-based Sentences**: Context-specific sentences based on accessibility roles
+3. **Language Support**: Translations in English and French
+4. **Accessibility Integration**: Role-based sentence generation
+
+## Development
+
+### Building
+
+Run `nx build dictionary` to build the library.
+
+### Running Unit Tests
+
+Run `nx test dictionary` to execute the unit tests via [Jest](https://jestjs.io).
+
+### Linting
+
+Run `nx lint dictionary` to lint the codebase.

package/dist/README.md

@@ -0,0 +1,57 @@
+# @uuv/dictionary
+
+[![npm version](https://badge.fury.io/js/%40uuv%2Fdictionary.svg)](https://badge.fury.io/js/%40uuv%2Fdictionary)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+This package provides a built-in set of Cucumber sentences for writing end-to-end tests with UUV. It includes translations in English and French, along with accessibility role-based sentence generation.
+
+## Features
+
+- Built-in Cucumber sentences for E2E testing
+- Support for multiple languages (English and French)
+- Role-based sentence generation for accessibility
+- Integration-ready with Cypress, Playwright, and Testing Library
+
+## Installation
+
+```bash
+npm install @uuv/dictionary
+```
+
+## Usage
+
+Import the dictionary in your test files:
+
+```typescript
+import { getDefinedDictionary } from '@uuv/dictionary';
+
+const dictionary = getDefinedDictionary('en'); // or 'fr' for French
+```
+
+### Available Dictionaries
+
+- English (`en`)
+- French (`fr`)
+
+## Structure
+
+The package contains:
+
+1. **Base Sentences**: General sentences for common actions
+2. **Role-based Sentences**: Context-specific sentences based on accessibility roles
+3. **Language Support**: Translations in English and French
+4. **Accessibility Integration**: Role-based sentence generation
+
+## Development
+
+### Building
+
+Run `nx build dictionary` to build the library.
+
+### Running Unit Tests
+
+Run `nx test dictionary` to execute the unit tests via [Jest](https://jestjs.io).
+
+### Linting
+
+Run `nx lint dictionary` to lint the codebase.

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { Dictionary } from "./lib/dictionary";
+export * from "./lib/dictionary";
+export * from "./lib/accessible-role";
+export * from "./lib/web";
+export * from "./lib/web/en";
+export * from "./lib/web/fr";
+export declare function getDefinedDictionary(lang: string): Dictionary;

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefinedDictionary = getDefinedDictionary;
+const tslib_1 = require("tslib");
+const dictionary_1 = require("./lib/dictionary");
+const fr_1 = require("./lib/web/fr");
+const en_1 = require("./lib/web/en");
+tslib_1.__exportStar(require("./lib/dictionary"), exports);
+tslib_1.__exportStar(require("./lib/accessible-role"), exports);
+tslib_1.__exportStar(require("./lib/web"), exports);
+tslib_1.__exportStar(require("./lib/web/en"), exports);
+tslib_1.__exportStar(require("./lib/web/fr"), exports);
+function getDefinedDictionary(lang) {
+    switch (lang) {
+        case dictionary_1.LANG.FR.toString():
+            return new fr_1.FrDictionary();
+        default:
+            return new en_1.EnDictionary();
+    }
+}

package/dist/lib/accessible-role.d.ts

@@ -0,0 +1,13 @@
+export declare abstract class AccessibleRole {
+    id: string;
+    name: string;
+    shouldGenerateClickSentence: boolean;
+    shouldGenerateTypeSentence: boolean;
+    shouldGenerateContainsSentence: boolean;
+    shouldGenerateKeyboardSentence: boolean;
+    shouldGenerateCheckedSentence: boolean;
+    abstract getDefiniteArticle(): string;
+    abstract getIndefiniteArticle(): string;
+    abstract getOfDefiniteArticle(): string;
+    abstract namedAdjective(): string;
+}

package/dist/lib/accessible-role.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessibleRole = void 0;
+class AccessibleRole {
+    id;
+    name;
+    shouldGenerateClickSentence;
+    shouldGenerateTypeSentence;
+    shouldGenerateContainsSentence;
+    shouldGenerateKeyboardSentence = false;
+    shouldGenerateCheckedSentence = false;
+}
+exports.AccessibleRole = AccessibleRole;

package/dist/lib/dictionary.d.ts

@@ -0,0 +1,32 @@
+import { AccessibleRole } from "./accessible-role";
+export declare enum LANG {
+    FR = "fr",
+    EN = "en"
+}
+export type BaseSentence = {
+    key: string;
+    description: string;
+    wording: string;
+};
+export type RoleBasedSentenceTemplate = BaseSentence & {
+    section: string;
+};
+export type RoleBasedSentence = RoleBasedSentenceTemplate & {
+    role: string;
+};
+export type ComputeSentenceInput = {
+    sentence: BaseSentence;
+    mock?: string;
+    accessibleRole: string;
+    parameters: string[];
+};
+export declare abstract class Dictionary {
+    protected baseSentences: BaseSentence[];
+    protected roleBasedSentencesTemplate: RoleBasedSentenceTemplate[];
+    protected roles: AccessibleRole[];
+    getBaseSentences(): BaseSentence[];
+    getRoleBasedSentencesTemplate(): RoleBasedSentenceTemplate[];
+    getDefinedRoles(): AccessibleRole[];
+    getRoleBasedSentences(): RoleBasedSentence[];
+    computeSentence(input: ComputeSentenceInput): string;
+}

package/dist/lib/dictionary.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dictionary = exports.LANG = void 0;
+var LANG;
+(function (LANG) {
+    LANG["FR"] = "fr";
+    LANG["EN"] = "en";
+})(LANG || (exports.LANG = LANG = {}));
+class Dictionary {
+    baseSentences;
+    roleBasedSentencesTemplate;
+    roles;
+    getBaseSentences() {
+        return this.baseSentences;
+    }
+    getRoleBasedSentencesTemplate() {
+        return this.roleBasedSentencesTemplate;
+    }
+    getDefinedRoles() {
+        return this.roles;
+    }
+    getRoleBasedSentences() {
+        const result = [];
+        this.roles.forEach(role => {
+            this.roleBasedSentencesTemplate
+                .filter(sentence => sentence.section === "general" ||
+                (sentence.section === "keyboard" && role.shouldGenerateKeyboardSentence) ||
+                (sentence.section === "click" && role.shouldGenerateClickSentence) ||
+                (sentence.section === "contains" && role.shouldGenerateContainsSentence) ||
+                (sentence.section === "type" && role.shouldGenerateTypeSentence) ||
+                (sentence.section === "checkable" && role.shouldGenerateCheckedSentence))
+                .map(sentence => {
+                return {
+                    ...sentence,
+                    role: role.name,
+                    key: `${sentence.key}.role.${role.name.toLowerCase()}`,
+                    wording: sentence.wording
+                        .replaceAll("(n)", "")
+                        .replaceAll("$roleName", role.name)
+                        .replaceAll("$definiteArticle", role.getDefiniteArticle())
+                        .replaceAll("$indefiniteArticle", role.getIndefiniteArticle())
+                        .replaceAll("$namedAdjective", role.namedAdjective())
+                        .replaceAll("$ofDefiniteArticle", role.getOfDefiniteArticle()),
+                };
+            })
+                .forEach(sentence => {
+                result.push(sentence);
+            });
+        });
+        return result;
+    }
+    computeSentence(input) {
+        const targetRole = this.getDefinedRoles().filter(role => role.id === input.accessibleRole)[0];
+        let resultSentence = input.sentence.wording;
+        if (input.mock) {
+            resultSentence = resultSentence.replace("{string}", `"${input.mock}"`);
+        }
+        resultSentence = resultSentence
+            .replaceAll("(n)", "")
+            .replaceAll("$roleName", targetRole?.name ?? input.accessibleRole)
+            .replaceAll("$definiteArticle", targetRole?.getDefiniteArticle())
+            .replaceAll("$indefiniteArticle", targetRole?.getIndefiniteArticle())
+            .replaceAll("$namedAdjective", targetRole?.namedAdjective())
+            .replaceAll("$ofDefiniteArticle", targetRole?.getOfDefiniteArticle());
+        input.parameters.forEach(param => {
+            resultSentence = resultSentence.replace("{string}", `"${param}"`);
+        });
+        return resultSentence;
+    }
+}
+exports.Dictionary = Dictionary;

package/dist/lib/web/en/en-enriched-wordings.json

@@ -0,0 +1,106 @@
+{
+    "enriched": [
+        {
+            "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}",
+            "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}",
+            "section": "general"
+        },
+        {
+            "key": "key.then.element.withRoleAndNameFocused",
+            "description": "Checks that the Html element 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/) is focused<br/><a target='_blank' href='https://github.com/e2e-test-quest/uuv/blob/main/example/en-keyboard.feature'>Examples</a>",
+            "wording": "I should see $indefiniteArticle $roleName named {string} keyboard focused",
+            "section": "keyboard"
+        },
+        {
+            "key": "key.then.element.nextWithRoleAndNameFocused",
+            "description": "Move to the next html element that can be reached with Tab and checks that the Html element 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/) is focused<br/><a target='_blank' href='https://github.com/e2e-test-quest/uuv/blob/main/example/en-keyboard.feature'>Examples</a>",
+            "wording": "the next keyboard element focused should be $indefiniteArticle $roleName named {string}",
+            "section": "keyboard"
+        },
+        {
+            "key": "key.then.element.previousWithRoleAndNameFocused",
+            "description": "Move to the previous html element that can be reached with Tab and checks that the Html element 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/) is focused<br/><a target='_blank' href='https://github.com/e2e-test-quest/uuv/blob/main/example/en-keyboard.feature'>Examples</a>",
+            "wording": "the previous keyboard element focused should be $indefiniteArticle $roleName named {string}",
+            "section": "keyboard"
+        },
+        {
+            "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}",
+            "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}",
+            "section": "contains"
+        },
+        {
+            "key": "key.then.element.withRoleAndNameAndValue",
+            "description": "Checks that an Form element(input) 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 specified value",
+            "wording": "I should see $indefiniteArticle $roleName named {string} with value {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",
+            "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",
+            "section": "contains"
+        },
+        {
+            "key": "key.then.element.withRoleAndNameDisabled",
+            "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 with the disabled attribute set to true",
+            "wording": "I should see $indefiniteArticle $roleName named {string} disabled",
+            "section": "contains"
+        },
+        {
+            "key": "key.then.element.withRoleAndNameEnabled",
+            "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 with the disabled attribute set to false",
+            "wording": "I should see $indefiniteArticle $roleName named {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}",
+            "section": "type"
+        },
+        {
+            "key": "key.then.element.withRoleAndNameAndChecked",
+            "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/) and is checked",
+            "wording": "I should see $indefiniteArticle $roleName named {string} checked",
+            "section": "checkable"
+        },
+        {
+            "key": "key.then.element.withRoleAndNameAndUnchecked",
+            "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/) and is unchecked",
+            "wording": "I should see $indefiniteArticle $roleName named {string} unchecked",
+            "section": "checkable"
+        },
+        {
+            "key": "key.when.enter",
+            "description": "Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)",
+            "wording": "I enter the value {string} in $definiteArticle $roleName named {string}",
+            "section": "type"
+        },
+        {
+            "key": "key.when.click",
+            "description": "Triggers a click on the element with role $roleId and the specified name",
+            "wording": "I click on $roleName named {string}",
+            "section": "click"
+        }
+    ]
+}

package/dist/lib/web/en/en-roles.d.ts

@@ -0,0 +1,2 @@
+import { AccessibleRole } from "../../accessible-role";
+export declare const EN_ROLES: AccessibleRole[];

package/dist/lib/web/en/en-roles.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EN_ROLES = void 0;
+const accessible_role_1 = require("../../accessible-role");
+var DEFINITE_ARTICLE;
+(function (DEFINITE_ARTICLE) {
+    DEFINITE_ARTICLE["THE"] = "the";
+})(DEFINITE_ARTICLE || (DEFINITE_ARTICLE = {}));
+var INDEFINITE_ARTICLE;
+(function (INDEFINITE_ARTICLE) {
+    INDEFINITE_ARTICLE["A"] = "a";
+    INDEFINITE_ARTICLE["AN"] = "an";
+})(INDEFINITE_ARTICLE || (INDEFINITE_ARTICLE = {}));
+class EnAccessibleRole extends accessible_role_1.AccessibleRole {
+    id;
+    name;
+    definiteArticle;
+    indefiniteArticle;
+    shouldGenerateClickSentence;
+    shouldGenerateTypeSentence;
+    shouldGenerateContainsSentence;
+    shouldGenerateKeyboardSentence;
+    shouldGenerateCheckedSentence;
+    constructor(id, name, definiteArticle = DEFINITE_ARTICLE.THE, indefiniteArticle = INDEFINITE_ARTICLE.A, shouldGenerateClickSentence = false, shouldGenerateTypeSentence = true, shouldGenerateContainsSentence = true, shouldGenerateKeyboardSentence = false, shouldGenerateCheckedSentence = false) {
+        super();
+        this.id = id;
+        this.name = name;
+        this.definiteArticle = definiteArticle;
+        this.indefiniteArticle = indefiniteArticle;
+        this.shouldGenerateClickSentence = shouldGenerateClickSentence;
+        this.shouldGenerateTypeSentence = shouldGenerateTypeSentence;
+        this.shouldGenerateContainsSentence = shouldGenerateContainsSentence;
+        this.shouldGenerateKeyboardSentence = shouldGenerateKeyboardSentence;
+        this.shouldGenerateCheckedSentence = shouldGenerateCheckedSentence;
+    }
+    static from(input) {
+        return new EnAccessibleRole(input.id, input.name, input.definiteArticle, input.indefiniteArticle, input.shouldGenerateClickSentence, input.shouldGenerateTypeSentence, input.shouldGenerateContainsSentence, input.shouldGenerateKeyboardSentence, input.shouldGenerateCheckedSentence);
+    }
+    getDefiniteArticle() {
+        return this.definiteArticle.toString();
+    }
+    getIndefiniteArticle() {
+        return this.indefiniteArticle.toString();
+    }
+    getOfDefiniteArticle() {
+        return `of ${this.definiteArticle}`;
+    }
+    namedAdjective() {
+        return "named";
+    }
+}
+exports.EN_ROLES = [
+    { id: "alert", name: "alert", indefiniteArticle: INDEFINITE_ARTICLE.AN },
+    { id: "alertdialog", name: "alert dialog", indefiniteArticle: INDEFINITE_ARTICLE.AN },
+    { id: "application", name: "application", indefiniteArticle: INDEFINITE_ARTICLE.AN },
+    { id: "article", name: "article", indefiniteArticle: INDEFINITE_ARTICLE.AN },
+    { id: "banner", name: "banner" },
+    { id: "button", name: "button", shouldGenerateKeyboardSentence: true, shouldGenerateClickSentence: true },
+    { id: "cell", name: "cell" },
+    { id: "checkbox", name: "checkbox", shouldGenerateKeyboardSentence: true, shouldGenerateCheckedSentence: true, shouldGenerateClickSentence: true },
+    { id: "columnheader", name: "column header" },
+    { id: "combobox", name: "combo box", shouldGenerateTypeSentence: false, shouldGenerateKeyboardSentence: true, shouldGenerateClickSentence: true },
+    { id: "command", name: "command" },
+    { id: "comment", name: "comment" },
+    { id: "complementary", name: "complementary" },
+    { id: "composite", name: "composite" },
+    { id: "contentinfo", name: "contentinfo" },
+    { id: "definition", name: "definition" },
+    { id: "dialog", name: "dialog" },
+    { id: "directory", name: "directory" },
+    { id: "document", name: "document" },
+    { id: "feed", name: "flow" },
+    { id: "figure", name: "figure" },
+    { id: "form", name: "form" },
+    { id: "generic", name: "generic" },
+    { id: "grid", name: "grid" },
+    { id: "gridcell", name: "grid cell" },
+    { id: "group", name: "group" },
+    { id: "heading", name: "title" },
+    { id: "img", name: "image", indefiniteArticle: INDEFINITE_ARTICLE.AN },
+    { id: "landmark", name: "landmark" },
+    { id: "link", name: "link", shouldGenerateKeyboardSentence: true, shouldGenerateClickSentence: true },
+    { id: "list", name: "list", shouldGenerateContainsSentence: false, shouldGenerateTypeSentence: false },
+    { id: "listbox", name: "list box", shouldGenerateKeyboardSentence: true },
+    { id: "listitem", name: "list item", shouldGenerateKeyboardSentence: true, shouldGenerateClickSentence: true },
+    { id: "log", name: "log" },
+    { id: "main", name: "main" },
+    { id: "mark", name: "mark" },
+    { id: "math", name: "math" },
+    { id: "menu", name: "menu" },
+    { id: "menubar", name: "menubar" },
+    { id: "menuitem", name: "menuitem", shouldGenerateKeyboardSentence: true, shouldGenerateClickSentence: true },
+    { id: "menuitemcheckbox", name: "menuitemcheckbox", shouldGenerateKeyboardSentence: true },
+    { id: "menuitemradio", name: "menuitemradio", shouldGenerateKeyboardSentence: true, shouldGenerateCheckedSentence: true },
+    { id: "meter", name: "counter" },
+    { id: "navigation", name: "navigation" },
+    { id: "none", name: "no" },
+    { id: "note", name: "note" },
+    { id: "option", name: "option", indefiniteArticle: INDEFINITE_ARTICLE.AN, shouldGenerateKeyboardSentence: true, shouldGenerateClickSentence: true },
+    { id: "presentation", name: "presentation" },
+    { id: "progressbar", name: "progress bar" },
+    { id: "radio", name: "radio", shouldGenerateKeyboardSentence: true, shouldGenerateCheckedSentence: true, shouldGenerateClickSentence: true },
+    { id: "radiogroup", name: "radio group" },
+    { id: "range", name: "range" },
+    { id: "region", name: "region" },
+    { id: "roletype", name: "role type" },
+    { id: "row", name: "row" },
+    { id: "rowgroup", name: "row group" },
+    { id: "rowheader", name: "row header" },
+    { id: "scrollbar", name: "scroll bar" },
+    { id: "search", name: "search", shouldGenerateKeyboardSentence: true },
+    { id: "searchbox", name: "search box", shouldGenerateKeyboardSentence: true },
+    { id: "section", name: "section" },
+    { id: "sectionhead", name: "section header" },
+    { id: "select", name: "select", shouldGenerateKeyboardSentence: true },
+    { id: "separator", name: "separator" },
+    { id: "slider", name: "slider", shouldGenerateKeyboardSentence: true },
+    { id: "spinbutton", name: "spin button", shouldGenerateKeyboardSentence: true },
+    { id: "status", name: "status" },
+    { id: "structure", name: "structure" },
+    { id: "suggestion", name: "suggestion" },
+    { id: "switch", name: "switch", shouldGenerateKeyboardSentence: true },
+    { id: "tab", name: "tab", shouldGenerateKeyboardSentence: true },
+    { id: "table", name: "table" },
+    { id: "tablist", name: "tablist" },
+    { id: "tabpanel", name: "tabpanel" },
+    { id: "term", name: "term" },
+    { id: "textbox", name: "text box", shouldGenerateKeyboardSentence: true },
+    { id: "timer", name: "timer" },
+    { id: "toolbar", name: "toolbar" },
+    { id: "tooltip", name: "tooltip" },
+    { id: "tree", name: "tree" },
+    { id: "treegrid", name: "tree grid" },
+    { id: "treeitem", name: "tree item" },
+    { id: "widget", name: "widget", shouldGenerateKeyboardSentence: true },
+    { id: "window", name: "window" }
+].map(role => EnAccessibleRole.from(role));