testaro 18.2.0 → 18.4.0

package/aslint/utils/aria.test.ts

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

package/aslint/utils/aria.ts

@@ -0,0 +1,120 @@
+import { ROLES, TAG_TO_IMPLICIT_SEMANTIC_INFO } from '../constants/aria';
+import { IElementRoles } from '../interfaces/aria.interface';
+import { CommonUtility } from './common';
+import { ObjectUtility } from './object';
+
+export class Aria {
+
+  public static getHtmlInfo(element: Element): any {
+    let htmlInfo: any;
+    let defaultInfo: any; // will contain the info with no specific selector if no others match;
+
+    if (ObjectUtility.isHtmlElement(element) === false) {
+      return null;
+    }
+
+    if (typeof element.tagName !== 'string') {
+      return null;
+    }
+
+    const tagName: string = element.tagName.toUpperCase();
+    const infos: string[] = TAG_TO_IMPLICIT_SEMANTIC_INFO[tagName as keyof typeof TAG_TO_IMPLICIT_SEMANTIC_INFO];
+
+    if (typeof infos === 'undefined') {
+      return null;
+    }
+
+    const len: number = infos.length;
+
+    defaultInfo = null; // will contain the info with no specific selector if no others match
+
+    for (let i: number = 0; i < len; i += 1) {
+      htmlInfo = infos[i];
+
+      if (htmlInfo.selector) {
+        if (element.matches(htmlInfo.selector)) {
+          return htmlInfo;
+        }
+      } else {
+        defaultInfo = htmlInfo;
+      }
+    }
+
+    return defaultInfo;
+  }
+
+  /**
+   * @param {Element} element
+   * @return {string} role
+   */
+
+  public static getImplicitRole(element: Element): string {
+    const htmlInfo: any = Aria.getHtmlInfo(element);
+
+    return htmlInfo ? htmlInfo.role : '';
+  }
+
+  /**
+   *
+   * Gets role details from an element.
+   * @param {Element} element The DOM element whose role we want.
+   * @param {boolean=} implicit if true then implicit semantics will be considered if there is no role attribute.
+   *
+   * @return {Object}
+   */
+  public static getRoles(element: Element, implicit?: boolean | undefined): IElementRoles | null {
+    let roleValue: string | null;
+    let role: any;
+    let ariaRole: any;
+    let roleObject: any;
+
+    if (typeof element === 'undefined' || element.nodeType !== Node.ELEMENT_NODE || element.hasAttribute('role') === false && (typeof implicit === 'boolean' && implicit === false)) {
+      return null;
+    }
+
+    roleValue = element.getAttribute('role');
+
+    if (roleValue === null && implicit) {
+      roleValue = Aria.getImplicitRole(element);
+    }
+
+    if (typeof roleValue === 'string' && roleValue.length === 0) { // role='' or implicit role came up empty
+      return null;
+    }
+
+    const roleNames: string[] = roleValue!.split(' ');
+
+    const result: IElementRoles = {
+      applied: {},
+      roles: [],
+      valid: false
+    };
+
+    for (let i: number = 0, len: number = roleNames.length; i < len; i += 1) {
+      role = roleNames[i];
+      ariaRole = ROLES[role];
+
+      roleObject = {
+        name: role
+      };
+
+      if (ariaRole && ariaRole.abstract === false) {
+        roleObject.details = ariaRole;
+
+        if (CommonUtility.hasKey(result, 'applied.name') === false) {
+          result.applied = roleObject;
+        }
+
+        roleObject.valid = result.valid = true;
+
+      } else {
+        roleObject.valid = false;
+      }
+
+      result.roles.push(roleObject);
+    }
+
+    return result;
+  }
+
+}

package/aslint/utils/async.test.ts

@@ -0,0 +1,25 @@
+import { Async } from './async';
+
+describe('Utils', () => {
+
+  describe('Async', () => {
+
+    describe('#run', () => {
+      jest.useFakeTimers();
+
+      it('should call function after specified time', () => {
+        const timerCallback = jest.fn();
+
+        Async.run(timerCallback, 500);
+
+        expect(timerCallback).not.toHaveBeenCalled();
+
+        jest.advanceTimersByTime(501);
+
+        expect(timerCallback).toHaveBeenCalled();
+      });
+
+    });
+
+  });
+});

package/aslint/utils/async.ts

@@ -0,0 +1,22 @@
+export class Async {
+  private static DEFAULT_TIMEOUT: number = 10;
+  private static DEFAULT_INTERVAL: number = 10;
+
+  constructor() { }
+
+  public static run(fn: any, context?: any, timeout?: number): number {
+    const callBack: any = context ? fn.bind(context) : fn;
+
+    return window.setTimeout(callBack, timeout || Async.DEFAULT_TIMEOUT);
+  }
+
+  public static interval(fn: any, context: any, intervalId: number): number {
+    const callBack: any = context ? fn.bind(context) : fn;
+
+    return window.setInterval(callBack, intervalId || Async.DEFAULT_INTERVAL);
+  }
+
+  public static stopInterval(id: number): void {
+    window.clearInterval(id);
+  }
+}

package/aslint/utils/common.test.ts

@@ -0,0 +1,239 @@
+import { CommonUtility } from './common';
+
+describe('Common', () => {
+  it('should indicate that class exists', () => {
+    const sharedCommonUtility = new CommonUtility();
+
+    expect(sharedCommonUtility).toBeDefined();
+  });
+
+  describe('#hasKey', (): void => {
+    it('should indicate that specified object has defined key', (): void => {
+      let obj;
+
+      let result;
+
+      obj = {
+        test: {
+          example: {
+            p: 1
+          }
+        }
+      };
+
+      result = CommonUtility.hasKey(obj, 'test.example.p');
+
+      expect(result).toBe(true);
+
+      obj = {
+        'a.b': 1
+      };
+
+      result = CommonUtility.hasKey(obj, ['a.b']);
+
+      expect(result).toBe(true);
+      expect(obj['a.b']).toBe(1);
+
+      obj = {
+        '': 1
+      };
+
+      result = CommonUtility.hasKey(obj, ['']);
+
+      expect(result).toBe(true);
+      expect(obj['']).toBe(1);
+    });
+
+    it('should indicate that specified object has no defined key', (): void => {
+      let obj = {};
+      let result = CommonUtility.hasKey(obj, 'test.example.p');
+
+      expect(result).toBe(false);
+
+      obj = null;
+      result = CommonUtility.hasKey(obj, 'test.example.p');
+
+      expect(result).toBe(false);
+
+      obj = [];
+      result = CommonUtility.hasKey(obj, 'test.example.p');
+
+      expect(result).toBe(false);
+    });
+
+    it('should indicate that specified object has defined key and the value under that property exists', () => {
+      const obj = {
+        foo: {
+          bar: 'baz'
+        }
+      };
+
+      const result = CommonUtility.hasKey(obj, 'foo.bar');
+
+      expect(result).toBe(true);
+      expect(obj.foo.bar).toBe('baz');
+    });
+  });
+
+  describe('#setKey', (): void => {
+    it('should create a property and set a value to an empty object', () => {
+      expect(CommonUtility.setKey({}, 'test.of.properties', null)).toEqual({
+        test: {
+          of: {
+            properties: null
+          }
+        }
+      });
+    });
+
+    it('should create a property and set a value to a non-empty object', () => {
+      expect(CommonUtility.setKey({
+        test: {}
+      }, 'test.of.properties', '6')).toEqual({
+        test: {
+          of: {
+            properties: '6'
+          }
+        }
+      });
+    });
+  });
+
+  describe('#pick', () => {
+    it('should pick values from object', () => {
+      const result: any = CommonUtility.pick(
+        {
+          ignoreThat: 'ignore',
+          object: {
+            shouldIgnoreThis: 'ignored',
+            some: 'value'
+          },
+          rootValue: 'root'
+        },
+        'rootValue',
+        'object.some'
+      );
+
+      expect(result).toEqual({
+        object: {
+          some: 'value'
+        },
+        rootValue: 'root'
+      });
+    });
+  });
+
+  describe('#pickArray', () => {
+    it('should pick values from objects in array', () => {
+      const result: any[] = CommonUtility.pickArray(
+        [
+          {
+            ignoreThat: 'ignore',
+            object: {
+              shouldIgnoreThis: 'ignored',
+              some: 'value'
+            },
+            rootValue: 'root'
+          },
+          {
+            ignore2: 'ignore',
+            rootValue: 'root 2'
+          }
+        ],
+        'rootValue',
+        'object.some'
+      );
+
+      expect(result).toEqual([{
+        object: {
+          some: 'value'
+        },
+        rootValue: 'root'
+      },
+      {
+        rootValue: 'root 2'
+      }
+      ]);
+    });
+  });
+
+  describe('#arrayToMap', () => {
+    it('should convert array of objects to map by property', () => {
+      type ValueStringType = { value: string };
+      const values: ValueStringType[] = [{
+        value: '1'
+      },
+      {
+        value: '2'
+      }];
+      const result: Map<string, ValueStringType> = CommonUtility.arrayToMap(values, 'value');
+
+      expect(Array.from(result.entries())).toEqual([
+        ['1', {
+          value: '1'
+        }],
+        ['2', {
+          value: '2'
+        }]
+      ]);
+    });
+
+    it('should convert array of objects to map by method return value', () => {
+      type ValueMethodType = { value: () => number };
+      const values: ValueMethodType[] = [{
+        value: () => {
+          return 1;
+        }
+      },
+      {
+        value: () => {
+          return 2;
+        }
+      }];
+      const result: Map<number, ValueMethodType> = CommonUtility.arrayToMap(values, 'value');
+
+      expect(Array.from(result.entries())).toEqual([
+        [1, values[0]],
+        [2, values[1]]
+      ]);
+    });
+  });
+
+  describe('#isNativeMethod', () => {
+
+    it('should determine that function method is a native, built-in method', () => {
+      expect(CommonUtility.isNativeMethod(String.prototype.trim)).toBeTruthy();
+    });
+
+    it('should determine that tested method is not a native, built-in method', () => {
+      const s: string = 'test';
+
+      expect(CommonUtility.isNativeMethod(s)).toBeFalsy();
+    });
+
+    it('should determine that object method is not a native, built-in method', () => {
+      const obj: object = {
+        a: 1,
+        b: 2
+      };
+
+      expect(CommonUtility.isNativeMethod(obj)).toBeFalsy();
+    });
+
+  });
+
+  describe('#isEventSupported', () => {
+    it('should indicate than "click" event is supported', () => {
+      const isClickEventSupported = CommonUtility.isEventSupported('click');
+
+      expect(isClickEventSupported).toBe(true);
+    });
+
+    it('should indicate than "foo" event is not supported', () => {
+      const isClickEventSupported = CommonUtility.isEventSupported('foo');
+
+      expect(isClickEventSupported).toBe(false);
+    });
+  });
+
+});

package/aslint/utils/common.ts

@@ -0,0 +1,168 @@
+import { ObjectUtility } from './object';
+
+type TypeOfKey<Type, Key extends keyof Type> = Type[Key] extends (...args: any[]) => any ? ReturnType<Type[Key]> : Type[Key];
+
+export class CommonUtility {
+
+  public static hasKey(obj: Object, key: string | string[]): boolean {
+    const keys: string[] = Array.isArray(key) ? key : key.split('.');
+    const len: number = keys.length;
+    let o: Object = obj;
+    let result: boolean = true;
+
+    if (o === null) {
+      result = false;
+
+      return result;
+    }
+
+    for (let i: number = 0; i < len; i += 1) {
+      if (typeof o !== 'object' || o === null || Object.prototype.hasOwnProperty.call(o, keys[i]) === false) {
+        result = false;
+        break;
+      }
+
+      o = o[keys[i] as keyof typeof o];
+    }
+
+    return result;
+  }
+
+  public static setKey(obj: Object, path: string, value: any): Object {
+    const pList: string[] = path.split('.');
+    const key: string | undefined = pList.pop();
+
+    const createPropertyWithValue = (accumulator: Object, currentValue: string): Object => {
+      if (typeof accumulator[currentValue as keyof typeof accumulator] === 'undefined') {
+        Object.defineProperty(accumulator, currentValue, {
+          configurable: true,
+          enumerable: true,
+          value: {},
+          writable: true
+        });
+      }
+
+      return accumulator[currentValue as keyof typeof accumulator];
+    };
+
+    if (typeof key === 'undefined') {
+      throw new Error('[Common.setKey] Invalid type of key. Should be stringm provided undefined');
+    }
+
+    const pointer: Object = pList.reduce(createPropertyWithValue, obj);
+
+    pointer[key as keyof typeof pointer] = value;
+
+    return obj;
+  }
+
+  public static pick<T, K extends keyof T>(value: T, ...props: Array<K | string>): Pick<T, K> | any {
+    const result: Pick<T, K> = {} as any;
+
+    for (const prop of props) {
+      if (prop as any in value) {
+        result[prop as K] = value[prop as K];
+      } else {
+        const path: string = prop as string;
+
+        if (CommonUtility.hasKey(value, path)) {
+          const deepValue: any = path.split('.').reduce((prev: any, current: string) => {
+            return prev[current];
+          }, value);
+
+          CommonUtility.setKey(result, path, deepValue);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  public static pickArray<T, K extends keyof T>(values: T[], ...props: Array<K | string>): Array<Pick<T, K> | any> {
+    return values.map((value: T) => {
+      return this.pick(value, ...props);
+    });
+  }
+
+  public static arrayToMap<T, K extends keyof T>(objects: T[], key: K): Map<TypeOfKey<T, K>, T> {
+    const getKey = (object: T): TypeOfKey<T, K> => {
+      return typeof object[key] === 'function' ? ((object[key] as unknown) as Function).call(object) : object[key];
+    };
+
+    return new Map<TypeOfKey<T, K>, T>(objects.map((object: T) => {
+      return [getKey(object), object];
+    }));
+  }
+
+  public static isHtmlDocument(el: any): boolean {
+    return Boolean(el) && el.nodeType === Node.DOCUMENT_NODE;
+  }
+
+  public static isNativeMethod(methodName: any): boolean {
+    const regEx: RegExp = new RegExp('^(function|object)$', 'i');
+    const argumentType: string = typeof methodName;
+    let str: string;
+
+    if (regEx.test(argumentType)) {
+      // Returns a string representing the object and check for [native code] string
+      str = String(methodName);
+
+      return str.indexOf('[native code]') !== -1;
+    }
+
+    return false;
+  }
+
+  public static randomRange(minVal: number = 0, max: number = 1000000): number {
+    const min: number = Math.ceil(minVal);
+
+    return Math.floor(Math.random() * (Math.floor(max) - min)) + min;
+  }
+
+  public static isEventSupported(event: string, htmlElement?: HTMLElement): boolean {
+    const TAGNAMES: { [key: string]: string } = {
+      abort: 'img',
+      change: 'input',
+      error: 'img',
+      load: 'img',
+      reset: 'form',
+      select: 'input',
+      submit: 'form'
+    };
+
+    let element: HTMLElement = htmlElement || document.createElement(TAGNAMES[event] || 'div');
+    const eventName: string = `on${event}`;
+
+    // When using `setAttribute`, IE skips "unload", WebKit skips "unload" and "resize", whereas `in` "catches" those
+    let isSupported: boolean = eventName in document;
+
+    if (isSupported === false) {
+      if (ObjectUtility.isHostMethod(element, 'setAttribute') === false) {
+        element = document.createElement('div');
+      }
+
+      if (ObjectUtility.isHostMethod(element, 'setAttribute') && ObjectUtility.isHostMethod(element, 'removeAttribute')) {
+        element.setAttribute(eventName, '');
+        isSupported = typeof element[eventName as keyof HTMLElement] === 'function';
+
+        if (typeof element[eventName as keyof HTMLElement] !== 'undefined') {
+          const descriptor: PropertyDescriptor | undefined = Object.getOwnPropertyDescriptor(element, eventName);
+
+          if (descriptor?.writable) {
+            Object.defineProperty(element, eventName, {
+              configurable: true,
+              enumerable: true,
+              value: undefined,
+              writable: true
+            });
+          }
+        }
+
+        element.removeAttribute(eventName);
+      }
+    }
+
+    return isSupported;
+  }
+
+}

package/aslint/utils/console.test.ts

@@ -0,0 +1,85 @@
+import { Console } from './console';
+import { Global } from './global';
+
+describe('Utils', () => {
+
+  describe('Console', () => {
+
+    let consoleObject: any, global: any;
+
+    beforeEach(() => {
+      global = {
+        console: {}
+      };
+    });
+
+    afterEach(() => {
+      consoleObject = undefined;
+    });
+
+    it('assigns global object when not provided in argument of console init', () => {
+      consoleObject = Console.init();
+      expect(consoleObject).toBe(Global.context.console);
+    });
+
+    it('checks, if custom method are applied (replaced native method)', () => {
+      consoleObject = Console.init(global);
+
+      Object.keys(consoleObject.config).forEach((key) => {
+        expect(typeof consoleObject[key]).toBe('function');
+        expect(consoleObject[key].toString().indexOf('[native code]')).toBeLessThan(0);
+      });
+    });
+
+    it('polyfill console.count when it does not exists', () => {
+
+      let consoleCountData: { test: any };
+
+      consoleObject = Console.init({});
+      consoleCountData = consoleObject.count('test');
+
+      expect(consoleObject.count).toBeDefined();
+      expect(consoleCountData.test).toBe(1);
+
+      consoleCountData = consoleObject.count('test');
+      expect(consoleCountData.test).toBe(2);
+    });
+
+    it('polyfill console.countReset should be created when it does not exists', () => {
+      consoleObject = Console.init({});
+      consoleObject.count('test');
+
+      const consoleCountData = consoleObject.countReset('test');
+
+      expect(typeof consoleObject.countReset).toBe('function');
+      expect(consoleCountData.test).toBe(0);
+    });
+
+    it('assign no-operation function when specified method does not exists in current console object', () => {
+      consoleObject = Console.init({});
+
+      expect(typeof consoleObject.assert).toBe('function');
+      expect(typeof consoleObject.clear).toBe('function');
+      expect(typeof consoleObject.count).toBe('function');
+      expect(typeof consoleObject.debug).toBe('function');
+      expect(typeof consoleObject.dir).toBe('function');
+      expect(typeof consoleObject.dirxml).toBe('function');
+      expect(typeof consoleObject.error).toBe('function');
+      expect(typeof consoleObject.group).toBe('function');
+      expect(typeof consoleObject.groupCollapsed).toBe('function');
+      expect(typeof consoleObject.groupEnd).toBe('function');
+      expect(typeof consoleObject.info).toBe('function');
+      expect(typeof consoleObject.log).toBe('function');
+      expect(typeof consoleObject.msIsIndependentlyComposed).toBe('function');
+      expect(typeof consoleObject.profile).toBe('function');
+      expect(typeof consoleObject.profileEnd).toBe('function');
+      expect(typeof consoleObject.select).toBe('function');
+      expect(typeof consoleObject.time).toBe('function');
+      expect(typeof consoleObject.timeEnd).toBe('function');
+      expect(typeof consoleObject.trace).toBe('function');
+      expect(typeof consoleObject.warn).toBe('function');
+    });
+
+  });
+
+});