testaro 18.1.1 → 18.2.0

package/aslint/app/rules/aslint/outline-zero/outline-zero.ts

@@ -0,0 +1,85 @@
+import { DomUtility } from '../../../utils/dom';
+import { CATEGORY_TYPE } from '../../../constants/categoryType';
+import { IIssueReport } from '../../../interfaces/rule-issue.interface';
+import { TextUtility } from '../../../utils/text';
+import { TranslateService } from '../../../services/translate';
+import { $severity } from '../../../constants/accessibility';
+import { Config } from '../../../config';
+import { $accessibilityAuditRules } from '../../../constants/accessibility';
+import { AbstractRule, IAbstractRuleConfig } from '../../abstract-rule';
+
+export class OutlineZero extends AbstractRule {
+  private appConfig: Config = Config.getInstance();
+
+  protected selector: () => CSSStyleSheet[] = (): CSSStyleSheet[] => {
+    return Array.from(document.styleSheets);
+  };
+
+  protected ruleConfig: IAbstractRuleConfig = {
+    id: TextUtility.convertUnderscoresToDashes($accessibilityAuditRules.outline_zero),
+    links: [
+      {
+        content: 'F55: Failure of Success Criteria 2.1.1, 2.4.7, and 3.2.1 due to using script to remove focus when focus is received',
+        url: 'https://www.w3.org/TR/WCAG20-TECHS/F55.html'
+      }
+    ],
+    recommendations: [],
+    severity: $severity.high,
+    type: CATEGORY_TYPE.BEST_PRACTICE
+  };
+
+  public validate(styleSheets: CSSStyleSheet[]): void {
+    if (styleSheets.length === 0) {
+      return;
+    }
+
+    const findOutlineZero = (styles: CSSStyleSheet): void => {
+      let currentRule: CSSRule;
+      let outlineWidthSize: number;
+      let selector: string;
+      let styleObject: any;
+      let isCSSembededInline: string;
+      let href: string | null;
+      const defaultSizeValues: string[] = ['thin', 'medium', 'thick'];
+
+      if (styles.hasOwnProperty('rules') === false || styles.href && styles.href.indexOf(this.appConfig.get('cssTitle')) !== -1) {
+        return;
+      }
+
+      const rules: CSSRuleList = styles.rules;
+      const rulesLength: number = rules.length;
+
+      for (let i: number = 0; i < rulesLength; i += 1) {
+        currentRule = rules[i];
+        styleObject = (currentRule as CSSStyleRule).style;
+
+        if (styleObject && styleObject.outlineWidth !== '' && defaultSizeValues.indexOf(styleObject.outlineWidth) === -1) {
+          outlineWidthSize = Number(styleObject.outlineWidth.replace(/[^\d.-]/g, ''));
+
+          if (outlineWidthSize === 0) {
+            href = (currentRule as any).parentStyleSheet.href;
+
+            if (href) {
+              isCSSembededInline = TranslateService.instant('outline_zero_css_embeded_1', [href]);
+            } else {
+              isCSSembededInline = TranslateService.instant('outline_zero_css_embeded_2', [DomUtility.getEscapedOuterHTML((currentRule as any).parentStyleSheet.ownerNode)]);
+            }
+
+            selector = currentRule.cssText.replace(/(outline.*?;)/i, '<em>$1</em>');
+            const reportMessage: string = TranslateService.instant('outline_zero_report_message', [styleObject.outlineWidth, selector, isCSSembededInline]);
+
+            const report: IIssueReport = {
+              message: reportMessage,
+              node: null,
+              ruleId: this.ruleConfig.id
+            };
+
+            this.validator.report(report);
+          }
+        }
+      }
+    };
+
+    styleSheets.forEach(findOutlineZero);
+  }
+}

package/aslint/app/rules/aslint/overlay/overlay.test.ts

@@ -0,0 +1,122 @@
+import { DomUtility } from '../../../utils/dom';
+import { Validator } from '../../../validator';
+import { Overlay } from './overlay';
+
+describe('Rules', () => {
+
+  describe('Overlay', () => {
+
+    it('should indicate that class exists', () => {
+      expect(Overlay).toBeDefined();
+    });
+
+    let fakeDom;
+
+    new Overlay().registerValidator();
+
+    beforeEach(() => {
+      fakeDom = document.createElement('div');
+      fakeDom.id = 'fakedom';
+      document.body.appendChild(fakeDom);
+
+      Validator.reset();
+    });
+
+    afterEach(() => {
+      DomUtility.remove(document.getElementById('fakedom'));
+      fakeDom = undefined;
+    });
+
+    it('should return 1 report when there is one known Overlay detected', () => {
+      fakeDom.innerHTML = '<script src="https://cdn.userway.org/widget.js"></script>';
+      const nodes = DomUtility.querySelectorAllExclude('script', fakeDom) as HTMLScriptElement[];
+
+      new Overlay().validate(nodes);
+
+      expect(Object.keys(Validator.getReports()).length).toBe(1);
+      expect(Validator.getReport('report_0').message).toBe('Accessibility overlay UserWay has been detected on the page. Overlays are third-party widgets that attempt to automatically fix the accessibility issues of page they are added to. Therefore the results from the scanning may not be accurate.');
+      expect(Validator.getReport('report_0').node.nodeName.toLowerCase()).toBe('script');
+      expect(Validator.getReport('report_0').ruleId).toBe('overlay');
+    });
+
+    it('should return 1 report when there is one known Overlay detected inside HTML', () => {
+      fakeDom.innerHTML = '<div data-src="https://cdn.userway.org/widget.js"></div>';
+      const nodes = DomUtility.querySelectorAllExclude('script', fakeDom) as HTMLScriptElement[];
+
+      new Overlay().validate(nodes);
+
+      expect(Object.keys(Validator.getReports()).length).toBe(1);
+      expect(Validator.getReport('report_0').message).toBe('Accessibility overlay UserWay has been detected on the page. Overlays are third-party widgets that attempt to automatically fix the accessibility issues of page they are added to. Therefore the results from the scanning may not be accurate.');
+      expect(Validator.getReport('report_0').node.nodeName.toLowerCase()).toBe('html');
+      expect(Validator.getReport('report_0').ruleId).toBe('overlay');
+    });
+
+    it('should return reports for all known detected overlays', () => {
+      let overlays: string = '';
+
+      overlays += '<script src="https://cdn.acsbap.com/widget.js"></script>';
+      overlays += '<script src="https://cdn.acsbapp.com/widget.js"></script>';
+      overlays += '<script src="https://cdn.audioeye.com/widget.js"></script>';
+      overlays += '<script src="https://cdn.nagich.com/widget.js"></script>';
+      overlays += '<script src="https://cdn.nagich.co.il/widget.js"></script>';
+      overlays += '<script src="https://cdn.maxaccess.io/widget.js"></script>';
+      overlays += '<script src="https://cdn.truabilities.com/widget.js"></script>';
+      overlays += '<script src="https://cdn.user1st.info/widget.js"></script>';
+      overlays += '<script src="https://cdn.userway.org/widget.js"></script>';
+
+      fakeDom.innerHTML = overlays;
+
+      const nodes = DomUtility.querySelectorAllExclude('script', fakeDom) as HTMLScriptElement[];
+
+      new Overlay().validate(nodes);
+
+      expect(Object.keys(Validator.getReports()).length).toBe(9);
+
+      expect(Validator.getReport('report_0').message).toBe('Accessibility overlay AccessiBe has been detected on the page. Overlays are third-party widgets that attempt to automatically fix the accessibility issues of page they are added to. Therefore the results from the scanning may not be accurate.');
+      expect(Validator.getReport('report_0').node.nodeName.toLowerCase()).toBe('script');
+      expect(Validator.getReport('report_0').ruleId).toBe('overlay');
+
+      expect(Validator.getReport('report_1').message).toBe('Accessibility overlay AccessiBe has been detected on the page. Overlays are third-party widgets that attempt to automatically fix the accessibility issues of page they are added to. Therefore the results from the scanning may not be accurate.');
+      expect(Validator.getReport('report_1').node.nodeName.toLowerCase()).toBe('script');
+      expect(Validator.getReport('report_1').ruleId).toBe('overlay');
+
+      expect(Validator.getReport('report_2').message).toBe('Accessibility overlay AudioEye has been detected on the page. Overlays are third-party widgets that attempt to automatically fix the accessibility issues of page they are added to. Therefore the results from the scanning may not be accurate.');
+      expect(Validator.getReport('report_2').node.nodeName.toLowerCase()).toBe('script');
+      expect(Validator.getReport('report_2').ruleId).toBe('overlay');
+
+      expect(Validator.getReport('report_3').message).toBe('Accessibility overlay EqualWeb has been detected on the page. Overlays are third-party widgets that attempt to automatically fix the accessibility issues of page they are added to. Therefore the results from the scanning may not be accurate.');
+      expect(Validator.getReport('report_3').node.nodeName.toLowerCase()).toBe('script');
+      expect(Validator.getReport('report_3').ruleId).toBe('overlay');
+
+      expect(Validator.getReport('report_4').message).toBe('Accessibility overlay EqualWeb has been detected on the page. Overlays are third-party widgets that attempt to automatically fix the accessibility issues of page they are added to. Therefore the results from the scanning may not be accurate.');
+      expect(Validator.getReport('report_4').node.nodeName.toLowerCase()).toBe('script');
+      expect(Validator.getReport('report_4').ruleId).toBe('overlay');
+
+      expect(Validator.getReport('report_5').message).toBe('Accessibility overlay MaxAccess has been detected on the page. Overlays are third-party widgets that attempt to automatically fix the accessibility issues of page they are added to. Therefore the results from the scanning may not be accurate.');
+      expect(Validator.getReport('report_5').node.nodeName.toLowerCase()).toBe('script');
+      expect(Validator.getReport('report_5').ruleId).toBe('overlay');
+
+      expect(Validator.getReport('report_6').message).toBe('Accessibility overlay TruAbilities has been detected on the page. Overlays are third-party widgets that attempt to automatically fix the accessibility issues of page they are added to. Therefore the results from the scanning may not be accurate.');
+      expect(Validator.getReport('report_6').node.nodeName.toLowerCase()).toBe('script');
+      expect(Validator.getReport('report_6').ruleId).toBe('overlay');
+
+      expect(Validator.getReport('report_7').message).toBe('Accessibility overlay User1st has been detected on the page. Overlays are third-party widgets that attempt to automatically fix the accessibility issues of page they are added to. Therefore the results from the scanning may not be accurate.');
+      expect(Validator.getReport('report_7').node.nodeName.toLowerCase()).toBe('script');
+      expect(Validator.getReport('report_7').ruleId).toBe('overlay');
+
+      expect(Validator.getReport('report_8').message).toBe('Accessibility overlay UserWay has been detected on the page. Overlays are third-party widgets that attempt to automatically fix the accessibility issues of page they are added to. Therefore the results from the scanning may not be accurate.');
+      expect(Validator.getReport('report_8').node.nodeName.toLowerCase()).toBe('script');
+      expect(Validator.getReport('report_8').ruleId).toBe('overlay');
+    });
+
+    it('should return no reports when there are no overlays on the page', () => {
+      fakeDom.innerHTML = '<script src="empty.js"></script>';
+      const nodes = DomUtility.querySelectorAllExclude('script', fakeDom) as HTMLScriptElement[];
+
+      new Overlay().validate(nodes);
+
+      expect(Object.keys(Validator.getReports()).length).toBe(0);
+    });
+
+  });
+});

package/aslint/app/rules/aslint/overlay/overlay.ts

@@ -0,0 +1,141 @@
+import { CATEGORY_TYPE } from '../../../constants/categoryType';
+import { IIssueReport } from '../../../interfaces/rule-issue.interface';
+import { TextUtility } from '../../../utils/text';
+import { TranslateService } from '../../../services/translate';
+import { $accessibilityAuditRules, $severity } from '../../../constants/accessibility';
+import { AbstractRule, IAbstractRuleConfig } from '../../abstract-rule';
+import { Context } from '../../../interfaces/context.interface';
+
+export class Overlay extends AbstractRule {
+  protected selector: string = 'script';
+
+  protected ruleConfig: IAbstractRuleConfig = {
+    id: TextUtility.convertUnderscoresToDashes($accessibilityAuditRules.overlay),
+    links: [
+      {
+        content: 'The Many Pitfalls of Accessibility Overlays',
+        url: 'https://www.essentialaccessibility.com/blog/the-many-pitfalls-of-accessibility-overlays'
+      }
+    ],
+    recommendations: [],
+    severity: $severity.high,
+    type: CATEGORY_TYPE.BEST_PRACTICE
+  };
+
+  public validate(scripts: HTMLScriptElement[]): void {
+    let foundedInScripts: boolean = false;
+
+    const findByScripts = (_overlayEntries: [string, string[]][]): void => {
+      const findOverlay = (script: HTMLScriptElement): void => {
+
+        let url: URL | null;
+
+        if (script.src.length === 0) {
+          // Note: this means script is inline embedded
+          return;
+        }
+
+        try {
+          url = new URL(script.src);
+        } catch (_) {
+          url = null;
+        }
+
+        if (url === null) {
+          return;
+        }
+
+        const hostname: string = url.hostname;
+        const foundedOverlays: Map<string, null> = new Map();
+
+        for (const [overlayName, overlayUrls] of _overlayEntries) {
+
+          for (const overlayUrl of overlayUrls) {
+            if (hostname.includes(overlayUrl)) {
+              foundedOverlays.set(overlayName, null);
+            }
+          }
+        }
+
+        if (Array.from(foundedOverlays).length === 0) {
+          return;
+        }
+
+        const reportMessage: string = TranslateService.instant('overlay_report_message', Array.from(foundedOverlays.keys()).join(', '));
+
+        const report: IIssueReport = {
+          message: reportMessage,
+          node: script,
+          ruleId: this.ruleConfig.id
+        };
+
+        this.validator.report(report);
+
+        foundedInScripts = true;
+      };
+
+      scripts.forEach(findOverlay);
+    };
+
+    const findThroughHtml = (_overlayEntries: [string, string[]][]): void => {
+      const context: Context = this.context;
+      let html: string = '';
+
+      if (typeof (context as any).innerHTML === 'string') {
+        html = (context as any).innerHTML;
+      } else if ((context as any).outerHTML === 'string') {
+        html = (context as any).outerHTML;
+      }
+
+      if (html.trim().length === 0) {
+        return;
+      }
+
+      const foundedOverlays: Map<string, null> = new Map();
+
+      for (const [overlayName, overlayUrls] of _overlayEntries) {
+
+        for (const overlayUrl of overlayUrls) {
+          if (html.includes(overlayUrl)) {
+            foundedOverlays.set(overlayName, null);
+          }
+        }
+      }
+
+      if (Array.from(foundedOverlays).length === 0) {
+        return;
+      }
+
+      const reportMessage: string = TranslateService.instant('overlay_report_message', Array.from(foundedOverlays.keys()).join(', '));
+
+      const report: IIssueReport = {
+        message: reportMessage,
+        node: context,
+        ruleId: this.ruleConfig.id
+      };
+
+      this.validator.report(report);
+    };
+
+    // Note: key of below object is later used as a name of overlay vendor
+    const overlay: { [key: string]: string[] } = {
+      AccessiBe: ['acsbap.com', 'acsbapp.com'],
+      AudioEye: ['audioeye.com'],
+      EqualWeb: ['nagich.com', 'nagich.co.il'],
+      MaxAccess: ['maxaccess.io'],
+      TruAbilities: ['truabilities.com'],
+      User1st: ['user1st.info'],
+      UserWay: ['userway.org']
+    };
+
+    const overlayEntries: [string, string[]][] = Object.entries(overlay);
+
+    if (scripts.length > 0) {
+      findByScripts(overlayEntries);
+    }
+
+    if (foundedInScripts === false) {
+      findThroughHtml(overlayEntries);
+    }
+  }
+}

package/aslint/app/rules/aslint/role-application/role-application.test.ts

@@ -0,0 +1,48 @@
+import { RoleApplication } from './role-application';
+import { Validator } from '../../../validator';
+import { DomUtility } from '../../../utils/dom';
+
+describe('Rules', () => {
+
+  describe('RoleApplication', () => {
+
+    let fakeDom;
+
+    new RoleApplication().registerValidator();
+
+    beforeEach(() => {
+      fakeDom = document.createElement('div');
+      fakeDom.id = 'fakedom';
+      document.body.appendChild(fakeDom);
+
+      Validator.reset();
+    });
+
+    afterEach(() => {
+      DomUtility.remove(document.getElementById('fakedom'));
+      fakeDom = undefined;
+    });
+
+    it('should return correct data for p with role="application"', () => {
+      fakeDom.innerHTML = '<p role="application"></p>';
+      const nodes = DomUtility.querySelectorAllExclude('[role="application"]', fakeDom) as HTMLElement[];
+
+      new RoleApplication().validate(nodes);
+
+      expect(Object.keys(Validator.getReports()).length).toBe(1);
+      expect(Validator.getReport('report_0').message).toBe('Use <code>role="application"</code> carefully as it is used to denote a region of a web application that is to be treated like a desktop application, not like a regular web page.');
+      expect(Validator.getReport('report_0').node.nodeName.toLowerCase()).toBe('p');
+      expect(Validator.getReport('report_0').ruleId).toBe('role-application');
+    });
+
+    it('should return no reports in case no elements with p with role="application"', () => {
+      fakeDom.innerHTML = '<p>Test</p>';
+      const nodes = DomUtility.querySelectorAllExclude('[role="application"]', fakeDom) as HTMLElement[];
+
+      new RoleApplication().validate(nodes);
+
+      expect(Object.keys(Validator.getReports()).length).toBe(0);
+    });
+
+  });
+});

package/aslint/app/rules/aslint/role-application/role-application.ts

@@ -0,0 +1,38 @@
+import { CATEGORY_TYPE } from '../../../constants/categoryType';
+import { IIssueReport } from '../../../interfaces/rule-issue.interface';
+import { TextUtility } from '../../../utils/text';
+import { TranslateService } from '../../../services/translate';
+import { $severity } from '../../../constants/accessibility';
+import { $accessibilityAuditRules } from '../../../constants/accessibility';
+import { AbstractRule, IAbstractRuleConfig } from '../../abstract-rule';
+
+export class RoleApplication extends AbstractRule {
+  protected selector: string = '[role="application"]';
+
+  protected ruleConfig: IAbstractRuleConfig = {
+    id: TextUtility.convertUnderscoresToDashes($accessibilityAuditRules.role_application),
+    links: [
+      {
+        content: 'Using ARIA role=application',
+        url: 'https://w3c.github.io/aria-in-html/'
+      }
+    ],
+    recommendations: [],
+    severity: $severity.critical,
+    type: CATEGORY_TYPE.BEST_PRACTICE
+  };
+
+  public validate(elements: HTMLElement[]): void {
+    const checkTabindex = (element: HTMLElement): void => {
+      const report: IIssueReport = {
+        message: TranslateService.instant('role_application_report_message'),
+        node: element,
+        ruleId: this.ruleConfig.id
+      };
+
+      this.validator.report(report);
+    };
+
+    elements.forEach(checkTabindex);
+  }
+}

package/aslint/app/rules/aslint/rtl-content/rtl-content.test.ts

@@ -0,0 +1,12 @@
+import { RtlContent } from './rtl-content';
+
+describe('Rules', () => {
+
+  describe('RtlContent', () => {
+
+    it('should indicate that class exists', () => {
+      expect(RtlContent).toBeDefined();
+    });
+
+  });
+});

package/aslint/app/rules/aslint/rtl-content/rtl-content.ts

@@ -0,0 +1,75 @@
+import { Css } from '../../../utils/css';
+import { CATEGORY_TYPE } from '../../../constants/categoryType';
+import { IIssueReport } from '../../../interfaces/rule-issue.interface';
+import { TextUtility } from '../../../utils/text';
+import { TranslateService } from '../../../services/translate';
+import { $severity } from '../../../constants/accessibility';
+import { $accessibilityAuditRules } from '../../../constants/accessibility';
+import { AbstractRule, IAbstractRuleConfig } from '../../abstract-rule';
+
+export class RtlContent extends AbstractRule {
+  protected selector: string = `*${[
+    ':root',
+    'head',
+    'style',
+    'script',
+    'meta',
+    'link',
+    'br',
+    'hr',
+    'object',
+    'path',
+    'g',
+    'filter',
+    'img',
+    'input',
+    'iframe',
+    'code',
+    ':empty'
+  ].map((i: string): string => {
+    return `:not(${i})`;
+  }).join('')}`;
+
+  protected ruleConfig: IAbstractRuleConfig = {
+    id: TextUtility.convertUnderscoresToDashes($accessibilityAuditRules.rtl_content),
+    links: [
+      {
+        content: 'Right to left implementation tricks',
+        url: 'http://www.ctomczyk.pl/right-to-left-implementation-tricks/642/'
+      }
+    ],
+    recommendations: [],
+    severity: $severity.info,
+    type: CATEGORY_TYPE.BEST_PRACTICE
+  };
+
+  public validate(elements: HTMLElement[]): any {
+    const nodesToReport: HTMLElement[] = [];
+
+    const reportRTL = (element: HTMLElement): void => {
+      if (element.nodeType !== element.ELEMENT_NODE) {
+        return;
+      }
+
+      const direction: string | null = Css.getStyle(element, 'direction');
+
+      if (typeof direction === 'string' && direction.toLowerCase() === 'rtl') {
+        nodesToReport.push(element);
+      }
+    };
+
+    elements.forEach(reportRTL);
+
+    const createReport = (element: HTMLElement): void => {
+      const problem: IIssueReport = {
+        message: TranslateService.instant('rtl_content_report_message'),
+        node: element,
+        ruleId: this.ruleConfig.id
+      };
+
+      this.validator.report(problem);
+    };
+
+    nodesToReport.forEach(createReport);
+  }
+}

package/aslint/app/rules/aslint/unclear-uri-on-a/unclear-anchor-uri.test.ts

@@ -0,0 +1,12 @@
+import { UnclearAnchorUri } from './unclear-anchor-uri';
+
+describe('Rules', () => {
+
+  describe('UnclearAnchorUri', () => {
+
+    it('should indicate that class exists', () => {
+      expect(UnclearAnchorUri).toBeDefined();
+    });
+
+  });
+});

package/aslint/app/rules/aslint/unclear-uri-on-a/unclear-anchor-uri.ts

@@ -0,0 +1,48 @@
+import { CATEGORY_TYPE } from '../../../constants/categoryType';
+import { IIssueReport } from '../../../interfaces/rule-issue.interface';
+import { TextUtility } from '../../../utils/text';
+import { TranslateService } from '../../../services/translate';
+import { $severity } from '../../../constants/accessibility';
+import { $accessibilityAuditRules } from '../../../constants/accessibility';
+import { AbstractRule, IAbstractRuleConfig } from '../../abstract-rule';
+
+export class UnclearAnchorUri extends AbstractRule {
+  protected selector: string = 'a[href="#"], a[href*=javascript\\:], a[href=""]';
+
+  protected ruleConfig: IAbstractRuleConfig = {
+    id: TextUtility.convertUnderscoresToDashes($accessibilityAuditRules.unclear_anchor_uri),
+    links: [
+      {
+        content: 'Making AJAX applications crawlable',
+        url: 'https://developers.google.com/webmasters/ajax-crawling/docs/learn-more#what-the-user-sees-what-the-crawler-sees'
+      }
+    ],
+    recommendations: [],
+    severity: $severity.high,
+    type: CATEGORY_TYPE.BEST_PRACTICE
+  };
+
+  public validate(anchorElements: HTMLAnchorElement[]): void {
+    const checkHref = (anchorElement: HTMLAnchorElement): void => {
+      const hrefAttr: string | null = anchorElement.getAttribute('href');
+
+      if (hrefAttr === null) {
+        return;
+      }
+
+      const report: IIssueReport = {
+        message: TranslateService.instant('unclear_uri_on_a_report_message_1', [anchorElement.href]),
+        node: anchorElement,
+        ruleId: this.ruleConfig.id
+      };
+
+      this.validator.report(report);
+    };
+
+    const nodesLength: number = anchorElements.length;
+
+    if (nodesLength) {
+      anchorElements.forEach(checkHref);
+    }
+  }
+}

package/aslint/app/rules/aslint/unsupported-role-on-element/unsupported-role-on-element.test.ts

@@ -0,0 +1,12 @@
+import { UnsupportedRoleOnElement } from './unsupported-role-on-element';
+
+describe('Rules', () => {
+
+  describe('UnsupportedRoleOnElement', () => {
+
+    it('should indicate that class exists', () => {
+      expect(UnsupportedRoleOnElement).toBeDefined();
+    });
+
+  });
+});

package/aslint/app/rules/aslint/unsupported-role-on-element/unsupported-role-on-element.ts

@@ -0,0 +1,63 @@
+import { CATEGORY_TYPE } from '../../../constants/categoryType';
+import { TAG_TO_IMPLICIT_SEMANTIC_INFO } from '../../../constants/aria';
+import { IIssueReport } from '../../../interfaces/rule-issue.interface';
+import { TextUtility } from '../../../utils/text';
+import { TranslateService } from '../../../services/translate';
+import { $severity } from '../../../constants/accessibility';
+import { $accessibilityAuditRules } from '../../../constants/accessibility';
+import { AbstractRule, IAbstractRuleConfig } from '../../abstract-rule';
+
+export class UnsupportedRoleOnElement extends AbstractRule {
+  protected selector: string = 'a[href="#"], a[href*=javascript\\:], a[href=""]';
+
+  protected ruleConfig: IAbstractRuleConfig = {
+    id: TextUtility.convertUnderscoresToDashes($accessibilityAuditRules.unsupported_role_on_element),
+    links: [],
+    recommendations: [],
+    severity: $severity.high,
+    type: CATEGORY_TYPE.BEST_PRACTICE
+  };
+
+  public validate(anchorElements: HTMLAnchorElement[]): void {
+    const checkSingleNode = (anchorElement: HTMLAnchorElement): void => {
+      const tagName: string = anchorElement.nodeName.toUpperCase();
+      const roleValue: string | null = anchorElement.getAttribute('role');
+
+      if (typeof TAG_TO_IMPLICIT_SEMANTIC_INFO[tagName] === 'undefined') {
+        return;
+      }
+
+      if (roleValue === null) {
+        return;
+      }
+
+      if (
+        Array.isArray(TAG_TO_IMPLICIT_SEMANTIC_INFO[tagName][0].allowed) &&
+        (TAG_TO_IMPLICIT_SEMANTIC_INFO[tagName][0].allowed as string[]).indexOf(
+          roleValue
+        ) !== -1
+      ) {
+        return;
+      }
+
+      const reportMessage: string = TranslateService.instant(
+        'unsupported_role_on_element_report_message',
+        [roleValue]
+      );
+
+      const report: IIssueReport = {
+        message: reportMessage,
+        node: anchorElement,
+        ruleId: this.ruleConfig.id
+      };
+
+      this.validator.report(report);
+    };
+
+    const nodesLength: number = anchorElements.length;
+
+    if (nodesLength > 0) {
+      anchorElements.forEach(checkSingleNode);
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testaro",
-  "version": "18.1.1",
+  "version": "18.2.0",
   "description": "Run 920 web accessibility tests from 9 tools and get a standardized report",
   "main": "index.js",
   "scripts": {