@uuv/dictionary 0.0.1

package/project.json

@@ -0,0 +1,124 @@
+{
+    "name": "dictionary",
+    "$schema": "../../node_modules/nx/schemas/project-schema.json",
+    "sourceRoot": "packages/dictionary/src",
+    "projectType": "library",
+    "tags": [],
+    "targets": {
+        "build": {
+            "executor": "@nx/js:tsc",
+            "outputs": ["{options.outputPath}"],
+            "options": {
+              "rootDir": "packages/dictionary/src",
+              "outputPath": "packages/dictionary/dist/",
+              "main": "packages/dictionary/src/index.ts",
+              "tsConfig": "packages/dictionary/tsconfig.lib.json",
+              "assets": [
+                "packages/dictionary/*.md"
+              ]
+            }
+        },
+        "test": {
+            "executor": "@nx/jest:jest",
+            "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+            "options": {
+                "jestConfig": "packages/dictionary/jest.config.ts"
+            }
+        },
+        "lint": {
+          "executor": "@nx/eslint:lint",
+          "outputs": [
+            "{options.outputFile}"
+          ],
+          "options": {
+            "lintFilePatterns": [
+              "packages/dictionary/src/**/*.ts"
+            ]
+          }
+        },
+        "semantic-release": {
+          "executor": "@theunderscorer/nx-semantic-release:semantic-release",
+          "options": {
+            "commitMessage": "release(dictionary): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}",
+            "plugins": [
+              [
+                "@semantic-release/npm",
+                {
+                  "npmPublish": false,
+                  "tarballDir": "dist/packages",
+                  "pkgRoot": "packages/dictionary"
+                }
+              ],
+              [
+                "@semantic-release/github",
+                {
+                  "successComment": false,
+                  "failComment": false,
+                  "assets": [
+                    {
+                      "path": "dist/packages/uuv-dictionary-*.tgz",
+                      "label": "Npm Package"
+                    }
+                  ]
+                }
+              ],
+              [
+                "@google/semantic-release-replace-plugin",
+                {
+                  "replacements": [
+                    {
+                      "files": [
+                        "packages/runner-commons/package.json"
+                      ],
+                      "from": "\"@uuv/dictionary\": \".*\"",
+                      "to": "\"@uuv/dictionary\": \"${nextRelease.version}\"",
+                      "results": [
+                        {
+                          "file": "packages/runner-commons/package.json",
+                          "hasChanged": true,
+                          "numMatches": 1,
+                          "numReplacements": 1
+                        }
+                      ],
+                      "countMatches": true
+                    },
+                    {
+                      "files": [
+                        "packages/assistant/package.json"
+                      ],
+                      "from": "\"@uuv/dictionary\": \".*\"",
+                      "to": "\"@uuv/dictionary\": \"${nextRelease.version}\"",
+                      "results": [
+                        {
+                          "file": "packages/assistant/package.json",
+                          "hasChanged": true,
+                          "numMatches": 1,
+                          "numReplacements": 1
+                        }
+                      ],
+                      "countMatches": true
+                    },
+                    {
+                      "files": [
+                        "packages/mcp-server/package.json"
+                      ],
+                      "from": "\"@uuv/dictionary\": \".*\"",
+                      "to": "\"@uuv/dictionary\": \"${nextRelease.version}\"",
+                      "results": [
+                        {
+                          "file": "packages/mcp-server/package.json",
+                          "hasChanged": true,
+                          "numMatches": 1,
+                          "numReplacements": 1
+                        }
+                      ],
+                      "countMatches": true
+                    }
+                  ]
+                }
+              ]
+            ]
+          }
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+import { Dictionary, LANG } from "./lib/dictionary";
+import { FrDictionary } from "./lib/web/fr";
+import { EnDictionary } from "./lib/web/en";
+
+export * from "./lib/dictionary";
+export * from "./lib/accessible-role";
+export * from "./lib/web";
+export * from "./lib/web/en";
+export * from "./lib/web/fr";
+
+export function getDefinedDictionary(lang: string): Dictionary {
+    switch (lang) {
+        case LANG.FR.toString():
+            return new FrDictionary();
+        default:
+            return new EnDictionary();
+    }
+}

package/src/lib/accessible-role.ts

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

package/src/lib/dictionary.spec.ts

@@ -0,0 +1,140 @@
+import { Dictionary } from "./dictionary";
+import { AccessibleRole } from "./accessible-role";
+
+class TestDictionary extends Dictionary {
+    protected override baseSentences = [
+        {
+            key: "test.key",
+            description: "Test description",
+            wording: "This is a test"
+        }
+    ];
+
+    protected override roleBasedSentencesTemplate = [
+        {
+            key: "role.test.key",
+            description: "Role based test description",
+            wording: "I should see $indefiniteArticle $roleName named {string}",
+            section: "general"
+        }
+    ];
+
+    protected override roles: AccessibleRole[] = [
+        {
+            id: "button",
+            name: "button",
+            shouldGenerateClickSentence: true,
+            shouldGenerateTypeSentence: false,
+            shouldGenerateContainsSentence: false,
+            shouldGenerateKeyboardSentence: true,
+            shouldGenerateCheckedSentence: false,
+            getDefiniteArticle(): string {
+                return "the";
+            },
+            getIndefiniteArticle(): string {
+                return "a";
+            },
+            getOfDefiniteArticle(): string {
+                return "of the";
+            },
+            namedAdjective(): string {
+                return "named";
+            }
+        }
+    ];
+}
+
+describe("Dictionary", () => {
+    let dictionary: TestDictionary;
+
+    beforeEach(() => {
+        dictionary = new TestDictionary();
+    });
+
+    describe("getBaseSentences", () => {
+        it("should return base sentences", () => {
+            const result = dictionary.getBaseSentences();
+            expect(result).toHaveLength(1);
+            expect(result[0].key).toBe("test.key");
+        });
+    });
+
+    describe("getRoleBasedSentencesTemplate", () => {
+        it("should return role based sentence templates", () => {
+            const result = dictionary.getRoleBasedSentencesTemplate();
+            expect(result).toHaveLength(1);
+            expect(result[0].key).toBe("role.test.key");
+        });
+    });
+
+    describe("getDefinedRoles", () => {
+        it("should return defined roles", () => {
+            const result = dictionary.getDefinedRoles();
+            expect(result).toHaveLength(1);
+            expect(result[0].id).toBe("button");
+        });
+    });
+
+    describe("getRoleBasedSentences", () => {
+        it("should generate role based sentences for all sections", () => {
+            const result = dictionary.getRoleBasedSentences();
+            expect(result).toHaveLength(1); // Only one role, so only one sentence generated
+            expect(result[0].key).toBe("role.test.key.role.button");
+            expect(result[0].role).toBe("button");
+        });
+
+        it("should properly replace placeholders in sentences", () => {
+            const result = dictionary.getRoleBasedSentences();
+            // The template has $indefiniteArticle and $roleName which should be replaced
+            expect(result[0].wording).toContain("a button named");
+        });
+    });
+
+    describe("computeSentence", () => {
+        it("should compute sentence with mock value", () => {
+            const input = {
+                sentence: {
+                    key: "test.key",
+                    description: "Test description",
+                    wording: "I type the sentence {string} in $definiteArticle $roleName named {string}"
+                },
+                mock: "test value",
+                accessibleRole: "button",
+                parameters: [ "myButton" ]
+            };
+
+            const result = dictionary.computeSentence(input);
+            expect(result).toEqual("I type the sentence \"test value\" in the button named \"myButton\"");
+        });
+
+        it("should compute sentence with parameters", () => {
+            const input = {
+                sentence: {
+                    key: "test.key",
+                    description: "Test description",
+                    wording: "I click on $roleName named {string} and containing {string}"
+                },
+                accessibleRole: "button",
+                parameters: ["parameter1", "parameter2"]
+            };
+
+            const result = dictionary.computeSentence(input);
+            expect(result).toEqual("I click on button named \"parameter1\" and containing \"parameter2\"");
+        });
+
+        it("should handle missing role gracefully", () => {
+            const input = {
+                sentence: {
+                    key: "test.key",
+                    description: "Test description",
+                    wording: "I type the sentence {string} in $definiteArticle $roleName named {string}"
+                },
+                accessibleRole: "nonexistent-role",
+                parameters: []
+            };
+
+            const result = dictionary.computeSentence(input);
+            expect(result).toEqual("I type the sentence {string} in undefined nonexistent-role named {string}");
+        });
+    });
+});

package/src/lib/dictionary.ts

@@ -0,0 +1,102 @@
+import { AccessibleRole } from "./accessible-role";
+
+export 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 abstract class Dictionary {
+    protected baseSentences!: BaseSentence[];
+    protected roleBasedSentencesTemplate!: RoleBasedSentenceTemplate[];
+    protected roles!: AccessibleRole[];
+
+    public getBaseSentences(): BaseSentence[] {
+        return this.baseSentences;
+    }
+
+    public getRoleBasedSentencesTemplate(): RoleBasedSentenceTemplate[] {
+        return this.roleBasedSentencesTemplate;
+    }
+
+    public getDefinedRoles(): AccessibleRole[] {
+        return this.roles;
+    }
+
+    public getRoleBasedSentences(): RoleBasedSentence[] {
+        const result: RoleBasedSentence[] = [];
+        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;
+    }
+
+    public computeSentence(input: ComputeSentenceInput): string {
+        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;
+    }
+}

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

@@ -0,0 +1,107 @@
+{
+  "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/src/lib/web/en/en-roles.ts

@@ -0,0 +1,144 @@
+import { AccessibleRole } from "../../accessible-role";
+
+enum DEFINITE_ARTICLE {
+    THE = "the"
+}
+
+enum INDEFINITE_ARTICLE {
+    A = "a",
+    AN = "an"
+}
+
+
+class EnAccessibleRole extends AccessibleRole {
+    constructor(
+        override id: string,
+        override name: string,
+        private definiteArticle: DEFINITE_ARTICLE = DEFINITE_ARTICLE.THE,
+        private indefiniteArticle: INDEFINITE_ARTICLE = INDEFINITE_ARTICLE.A,
+        override shouldGenerateClickSentence = false,
+        override shouldGenerateTypeSentence = true,
+        override shouldGenerateContainsSentence = true,
+        override shouldGenerateKeyboardSentence = false,
+        override shouldGenerateCheckedSentence = false
+    ) {
+        super();
+    }
+
+    public static from(input: any) : AccessibleRole {
+        return new EnAccessibleRole(
+            input.id,
+            input.name,
+            input.definiteArticle,
+            input.indefiniteArticle,
+            input.shouldGenerateClickSentence,
+            input.shouldGenerateTypeSentence,
+            input.shouldGenerateContainsSentence,
+            input.shouldGenerateKeyboardSentence,
+            input.shouldGenerateCheckedSentence
+        );
+    }
+
+    override getDefiniteArticle(): string {
+        return this.definiteArticle.toString();
+    }
+
+    override getIndefiniteArticle(): string {
+        return this.indefiniteArticle.toString();
+    }
+
+    override getOfDefiniteArticle(): string {
+        return `of ${this.definiteArticle}`;
+    }
+
+    override namedAdjective(): string {
+        return "named";
+    }
+}
+
+export const EN_ROLES: AccessibleRole[] = [
+    { 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));