testaro 18.1.1 → 18.2.0

package/aslint/app/rules/aslint/misused-aria-on-focusable-element/misused-aria-on-focusable-element.ts

@@ -0,0 +1,66 @@
+import { DomUtility } from '../../../utils/dom';
+import { CATEGORY_TYPE } from '../../../constants/categoryType';
+import { FOCUSABLE_ELEMENTS } from '../../../constants/focusableElements';
+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 MisusedAriaOnFocusableElement extends AbstractRule {
+  protected selector: string = FOCUSABLE_ELEMENTS
+    .map((i: string): string => {
+      return `${i}[role="presentation"], ${i}[aria-hidden="true"]`;
+    })
+    .join(', ');
+
+  protected ruleConfig: IAbstractRuleConfig = {
+    id: TextUtility.convertUnderscoresToDashes($accessibilityAuditRules.misused_aria_on_focusable_element),
+    links: [
+      {
+        content: 'Do not use role="presentation" or aria-hidden="true" on a visible focusable element',
+        url: 'https://w3c.github.io/using-aria/#4thrule'
+      }
+    ],
+    recommendations: [],
+    severity: $severity.high,
+    type: CATEGORY_TYPE.BEST_PRACTICE
+  };
+
+  public validate(elements: HTMLElement[]): void {
+    const checkSupportForTabindex = (element: HTMLElement): void => {
+      const rolePresentation: string | null = element.getAttribute('role');
+      const ariaHiddenTrue: string | null = element.getAttribute('aria-hidden');
+      const attributesToReport: string[] = [];
+
+      if (DomUtility.isElementHidden(element)) {
+        return;
+      }
+
+      if (rolePresentation) {
+        const attribute: string = TranslateService.instant('misused_aria_on_focusable_element_attribute_1');
+
+        attributesToReport.push(attribute);
+      }
+
+      if (ariaHiddenTrue === 'true') {
+        const attribute: string = TranslateService.instant('misused_aria_on_focusable_element_attribute_2');
+
+        attributesToReport.push(attribute);
+      }
+
+      const reportMessage: string = TranslateService.instant('misused_aria_on_focusable_element_report_message', [attributesToReport.join(', ')]);
+
+      const report: IIssueReport = {
+        message: reportMessage,
+        node: element,
+        ruleId: this.ruleConfig.id
+      };
+
+      this.validator.report(report);
+    };
+
+    elements.forEach(checkSupportForTabindex);
+  }
+}

package/aslint/app/rules/aslint/misused-input-attribute/misused-input-attribute.test.ts

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

package/aslint/app/rules/aslint/misused-input-attribute/misused-input-attribute.ts

@@ -0,0 +1,134 @@
+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 MisusedInputAttribute extends AbstractRule {
+  protected selector: string = 'input';
+  protected ruleConfig: IAbstractRuleConfig = {
+    id: TextUtility.convertUnderscoresToDashes($accessibilityAuditRules.misused_input_attribute),
+    links: [
+      {
+        content: 'HTML5 form additions',
+        url: 'https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input'
+      },
+      {
+        content: 'Common input element attributes',
+        url: 'https://www.w3.org/TR/html5/forms.html#common-input-element-attributes'
+      }
+    ],
+    recommendations: [],
+    severity: $severity.high,
+    type: CATEGORY_TYPE.BEST_PRACTICE
+  };
+
+  public validate(elements: Element[]): void {
+    const SUPPORTED_INPUT_ATTRIBUTES: string[] = [
+      'accept',
+      'accessKey',
+      'autocapitalize',
+      'autocomplete',
+      'autofocus',
+      'checked',
+      'defaultChecked',
+      'defaultValue',
+      'dirName',
+      'disabled',
+      'indeterminate',
+      'list',
+      'maxLength',
+      'minLength',
+      'min',
+      'max',
+      'multiple',
+      'name',
+      'pattern',
+      'placeholder',
+      'readOnly',
+      'required',
+      'selectionDirection',
+      'selectionEnd',
+      'selectionStart',
+      'size',
+      'src',
+      'step',
+      'tabIndex',
+      'type',
+      'useMap',
+      'value',
+      'valueAsDate',
+      'valueAsNumber',
+      'width',
+      'willValidate'
+    ];
+
+    const attributeAliases: any = {
+      accesskey: 'accessKey',
+      cellpadding: 'cellPadding',
+      cellspacing: 'cellSpacing',
+      class: 'className',
+      codebase: 'codeBase',
+      colspan: 'colSpan',
+      defaultchecked: 'defaultChecked',
+      defaultvalue: 'defaultValue',
+      dirname: 'dirName',
+      for: 'htmlFor',
+      formaction: 'formAction',
+      formenctype: 'formEncType',
+      formmethod: 'formMethod',
+      formnovalidate: 'formNoValidate',
+      formtarget: 'formTarget',
+      frameborder: 'frameBorder',
+      framespacing: 'frameSpacing',
+      ismap: 'isMap',
+      longdesc: 'longDesc',
+      maxlength: 'maxLength',
+      nowrap: 'noWrap',
+      placeholder: 'placeholder',
+      readonly: 'readOnly',
+      rowspan: 'rowSpan',
+      selectiondirection: 'selectionDirection',
+      selectionend: 'selectionEnd',
+      selectionstart: 'selectionStart',
+      tabindex: 'tabIndex',
+      usemap: 'useMap',
+      validationmessage: 'validationMessage',
+      valueasdate: 'valueAsDate',
+      valueasnumber: 'valueAsNumber',
+      willvalidate: 'willValidate'
+    };
+
+    const isSupportedAttribute = (element: Element, attribute: string): boolean => {
+      const alias: string = attributeAliases[attribute.toLowerCase()] || attribute;
+
+      return alias in element;
+    };
+
+    const checkSupportForInputAttribute = (element: Element): void => {
+      let nodeAttrValue: string | null;
+
+      const checkAttributes = (attr: string): void => {
+        nodeAttrValue = element.getAttribute(attr);
+
+        if (typeof nodeAttrValue === 'string' && isSupportedAttribute(element, attr) === false) {
+          const reportMessage: string = TranslateService.instant('misused_input_attribute_report_message', [attr]);
+
+          const report: IIssueReport = {
+            message: reportMessage,
+            node: element,
+            ruleId: this.ruleConfig.id
+          };
+
+          this.validator.report(report);
+        }
+      };
+
+      SUPPORTED_INPUT_ATTRIBUTES.forEach(checkAttributes);
+    };
+
+    elements.forEach(checkSupportForInputAttribute);
+  }
+}

package/aslint/app/rules/aslint/misused-required-attribute/misused-required-attribute.test.ts

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

package/aslint/app/rules/aslint/misused-required-attribute/misused-required-attribute.ts

@@ -0,0 +1,90 @@
+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 MisusedRequiredAttribute extends AbstractRule {
+  protected selector: string = '[required][aria-required]';
+
+  protected ruleConfig: IAbstractRuleConfig = {
+    id: TextUtility.convertUnderscoresToDashes($accessibilityAuditRules.misused_required_attribute),
+    links: [
+      {
+        content: 'Attribute required',
+        url: 'https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-required'
+      }
+    ],
+    recommendations: [],
+    severity: $severity.high,
+    type: CATEGORY_TYPE.BEST_PRACTICE
+  };
+
+  public validate(elements: HTMLElement[]): void {
+    const requiredElms: HTMLElement[] = elements;
+    const notUseOnType: string[] = [
+      'hidden',
+      'image'
+    ];
+    const notUseOnButtonType: string[] = [
+      'submit',
+      'reset',
+      'button'
+    ];
+
+    const showMessage = (element: HTMLElement): void => {
+      let report: IIssueReport | undefined;
+      const ariaRequiredValue: string | null = element.getAttribute('aria-required');
+      const elementRequiredValue: string | null = element.getAttribute('required');
+      const nodeName: string = element.nodeName.toLowerCase();
+
+      if (ariaRequiredValue && elementRequiredValue === null ||
+        (typeof (element as any).type === 'string' && notUseOnType.indexOf((element as any).type) !== -1 ||
+        nodeName === 'button' && notUseOnButtonType.indexOf((element as HTMLButtonElement).type) !== -1)
+      ) {
+        const reportMessage: string = TranslateService.instant('misused_required_attribute_report_message1', [ariaRequiredValue]);
+
+        report = {
+          message: reportMessage,
+          node: element,
+          ruleId: this.ruleConfig.id
+        };
+
+        this.validator.report(report);
+
+        return;
+      }
+
+      if (elementRequiredValue === null) {
+        return;
+      }
+
+      if (elementRequiredValue === ariaRequiredValue) {
+        const reportMessage: string = TranslateService.instant('misused_required_attribute_report_message2', [ariaRequiredValue]);
+
+        report = {
+          message: reportMessage,
+          node: element,
+          ruleId: this.ruleConfig.id
+        };
+      } else {
+        const reportMessage: string = TranslateService.instant('misused_required_attribute_report_message3', [ariaRequiredValue, element.getAttribute('required')]);
+
+        report = {
+          message: reportMessage,
+          node: element,
+          ruleId: this.ruleConfig.id
+        };
+      }
+
+      if (typeof report === 'undefined') {
+        return;
+      }
+
+      this.validator.report(report);
+    };
+
+    requiredElms.forEach(showMessage);
+  }
+}

package/aslint/app/rules/aslint/navigation-landmark-restrictions/navigation-landmark-restrictions.test.ts

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

package/aslint/app/rules/aslint/navigation-landmark-restrictions/navigation-landmark-restrictions.ts

@@ -0,0 +1,48 @@
+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 { $accessibilityAuditRules } from '../../../constants/accessibility';
+import { AbstractRule, IAbstractRuleConfig } from '../../abstract-rule';
+
+export class NavigationLandmarkRestrictions extends AbstractRule {
+  protected selector: string = '[role="navigation"]';
+
+  protected ruleConfig: IAbstractRuleConfig = {
+    id: TextUtility.convertUnderscoresToDashes($accessibilityAuditRules.navigation_landmark_restrictions),
+    links: [
+      {
+        content: 'Accessible Rich Internet Applications (WAI-ARIA) 1.0 Specification: navigation role',
+        url: 'https://www.w3.org/TR/wai-aria-1.1/#navigation'
+      }
+    ],
+    recommendations: [],
+    severity: $severity.high,
+    type: CATEGORY_TYPE.BEST_PRACTICE
+  };
+
+  public validate(elements: Element[]): void {
+    const selector: string = '[role]:not([role="region"]):not([role="search"])';
+    const reportMessage: string = TranslateService.instant('navigation_landmark_restrictions_report_message');
+
+    const checkRoleNavigationContent = (htmlElement: Element): void => {
+      const childs: HTMLElement[] = DomUtility.querySelectorAll(selector, htmlElement);
+
+      const reportIssue = (element: Element): void => {
+        const report: IIssueReport = {
+          message: reportMessage,
+          node: element,
+          ruleId: this.ruleConfig.id
+        };
+
+        this.validator.report(report);
+      };
+
+      childs.forEach(reportIssue);
+    };
+
+    elements.forEach(checkRoleNavigationContent);
+  }
+}

package/aslint/app/rules/aslint/obsolete-html-attributes/obsolete-html-attributes.test.ts

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

package/aslint/app/rules/aslint/obsolete-html-attributes/obsolete-html-attributes.ts

@@ -0,0 +1,148 @@
+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';
+
+const OBSOLETE_HTML_ATTRIBUTES: { [key: string]: string[] } = {
+  accept: ['form'],
+  align: ['caption', 'col', 'div', 'embed', 'hr', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'iframe', 'input', 'img', 'legend', 'object', 'p', 'table', 'tbody', 'thead', 'tfoot', 'td', 'th', 'tr'],
+  alink: ['body'],
+  allowtransparency: ['iframe'],
+  archive: ['object'],
+  axis: ['td', 'th'],
+  background: ['body', 'table', 'thead', 'tbody', 'tfoot', 'tr', 'td', 'th'],
+  bgcolor: ['body', 'table', 'td', 'th', 'tr'],
+  border: ['img', 'object'],
+  bordercolor: ['table'],
+  cellpadding: ['table'],
+  cellspacing: ['table'],
+  char: ['col', 'tbody', 'thead', 'tfoot', 'td', 'th', 'tr'],
+  charoff: ['col', 'tbody', 'thead', 'tfoot', 'td', 'th', 'tr'],
+  charset: ['a', 'link'],
+  classid: ['object'],
+  clear: ['br'],
+  code: ['object'],
+  codebase: ['object'],
+  codetype: ['object'],
+  color: ['hr'],
+  compact: ['dl', 'ol', 'ul'],
+  coords: ['a'],
+  datafld: ['a', 'applet', 'button', 'div', 'fieldset', 'frame', 'iframe', 'img', 'input', 'label', 'legend', 'marquee', 'object', 'param', 'select', 'span', 'textarea'],
+  dataformatas: ['button', 'div', 'input', 'label', 'legend', 'marquee', 'object', 'option', 'select', 'span', 'table'],
+  datapagesize: ['table'],
+  datasrc: ['a', 'applet', 'button', 'div', 'frame', 'iframe', 'img', 'input', 'label', 'legend', 'marquee', 'object', 'option', 'select', 'span', 'table', 'textarea'],
+  declare: ['object'],
+  event: ['script'],
+  for: ['script'],
+  frame: ['table'],
+  frameborder: ['iframe'],
+  height: ['td', 'th'],
+  hspace: ['embed', 'iframe', 'input', 'img', 'object'],
+  ismap: ['input'],
+  language: ['script'],
+  link: ['body'],
+  lowsrc: ['img'],
+  marginbottom: ['body'],
+  marginheight: ['body', 'iframe'],
+  marginleft: ['body'],
+  marginright: ['body'],
+  margintop: ['body'],
+  marginwidth: ['body', 'iframe'],
+  methods: ['a', 'link'],
+  name: ['a', 'embed', 'img', 'option'],
+  nohref: ['area'],
+  noshade: ['hr'],
+  nowrap: ['td', 'th'],
+  profile: ['head'],
+  rules: ['table'],
+  scheme: ['meta'],
+  scope: ['td'],
+  scrolling: ['iframe'],
+  shape: ['a'],
+  size: ['hr'],
+  standby: ['object'],
+  summary: ['table'],
+  target: ['link'],
+  text: ['body'],
+  type: ['param', 'li', 'ul'],
+  urn: ['a', 'link'],
+  usemap: ['input'],
+  valign: ['col', 'tbody', 'thead', 'tfoot', 'td', 'th', 'tr'],
+  valuetype: ['param'],
+  version: ['html'],
+  vlink: ['body'],
+  vspace: ['embed', 'iframe', 'input', 'img', 'object'],
+  width: ['col', 'hr', 'pre', 'table', 'td', 'th']
+};
+
+export class ObsoleteHtmlAttributes extends AbstractRule {
+  protected selector: string = (() => {
+    const createSelector = (elementData: [string, string[]]): string => {
+      const attribute: string = elementData[0];
+      const elements: string[] = elementData[1];
+
+      const create = (elementName: string): string => {
+        return `${elementName}[${attribute}]`;
+      };
+
+      return elements.map(create).join(',');
+    };
+
+    const selector: string = Object.entries(OBSOLETE_HTML_ATTRIBUTES).map(createSelector)
+      .join(',');
+
+    return selector;
+  })();
+
+  protected ruleConfig: IAbstractRuleConfig = {
+    id: TextUtility.convertUnderscoresToDashes($accessibilityAuditRules.obsolete_html_attributes),
+    links: [
+      {
+        content: 'Non-conforming features',
+        url: 'https://www.w3.org/TR/html5/obsolete.html#non-conforming-features'
+      }
+    ],
+    recommendations: [],
+    severity: $severity.high,
+    type: CATEGORY_TYPE.BEST_PRACTICE
+  };
+
+  public validate(elements: HTMLElement[]): void {
+    const reportNode = (element: HTMLElement): void => {
+
+      const attributes: Attr[] = Array.from(element.attributes);
+      const foundedAttributes: string[] = [];
+
+      const checkAttribute = (attr: Attr): void => {
+        const elms: string[] | undefined = OBSOLETE_HTML_ATTRIBUTES[attr.localName];
+
+        if (Array.isArray(elms)) {
+          if (elms.includes(element.nodeName.toLowerCase())) {
+            foundedAttributes.push(attr.localName);
+          }
+        }
+      };
+
+      attributes.forEach(checkAttribute);
+
+      if (foundedAttributes.length === 0) {
+        return;
+      }
+
+      const reportMessage: string = TranslateService.instant('obsolete_html_attributes_report_message', foundedAttributes.join(', '));
+
+      const report: IIssueReport = {
+        message: reportMessage,
+        node: element,
+        ruleId: this.ruleConfig.id
+      };
+
+      this.validator.report(report);
+    };
+
+    elements.forEach(reportNode);
+  }
+}

package/aslint/app/rules/aslint/obsolete-html-elements/obsolete-html-elements.test.ts

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

package/aslint/app/rules/aslint/obsolete-html-elements/obsolete-html-elements.ts

@@ -0,0 +1,66 @@
+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 ObsoleteHtmlElements extends AbstractRule {
+  protected selector: string = [
+    'acronym',
+    'applet',
+    'basefont',
+    'bgsound',
+    'big',
+    'blink',
+    'center',
+    'dir',
+    'font',
+    'frame',
+    'frameset',
+    'hgroup',
+    'isindex',
+    'listing',
+    'marquee',
+    'multicol',
+    'nextid',
+    'nobr',
+    'noembed',
+    'noframes',
+    'plaintext',
+    's',
+    'spacer',
+    'strike',
+    'tt',
+    'u',
+    'xmp'
+  ].join(', ');
+
+  protected ruleConfig: IAbstractRuleConfig = {
+    id: TextUtility.convertUnderscoresToDashes($accessibilityAuditRules.obsolete_html_elements),
+    links: [
+      {
+        content: 'Non-conforming features',
+        url: 'https://www.w3.org/TR/html5/obsolete.html#non-conforming-features'
+      }
+    ],
+    recommendations: [],
+    severity: $severity.high,
+    type: CATEGORY_TYPE.BEST_PRACTICE
+  };
+
+  public validate(elements: HTMLElement[]): void {
+    const reportNode = (element: HTMLElement): void => {
+      const problem: IIssueReport = {
+        message: TranslateService.instant('obsolete_html_elements_report_message', [element.nodeName.toLowerCase()]),
+        node: element,
+        ruleId: this.ruleConfig.id
+      };
+
+      this.validator.report(problem);
+    };
+
+    elements.forEach(reportNode);
+  }
+}

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

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