testaro 27.0.0 → 28.0.0

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

@@ -1,134 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

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

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

@@ -1,85 +0,0 @@
-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);
-  }
-}