4066

Build # 4066

Build Type

push

travis-ci

Committed by Ezra Shim

Commit Message

Merge branch 'f/datePickerInput' of https://github.com/bullhorn/novo-elements into f/datePickerInput

Run Details

1319 of 3839 branches covered (34.36%)

379 of 379 new or added lines in 16 files covered. (100.0%)

4335 of 7317 relevant lines covered (59.25%)

11.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

26.99

/src/platform/utils/Helpers.ts

export class Helpers {
  /**
   * Swallows an event to stop further execution
   * @param event
   */
  static swallowEvent(event) {
    if (event) {
      event.stopPropagation();
      event.preventDefault();
    }
  }

  static interpolate(str: string, props: any): string {
    return str.replace(/\$([\w\.]+)/g, (original, key) => {
      let keys = key.split('.');
      let value = props[keys.shift()];
      while (keys.length && value !== undefined) {
        let k = keys.shift();
        value = k ? value[k] : `${value}.`;
      }
      return value !== undefined ? value : '';
    });
  }

  static interpolateWithFallback(formatString: string | string[], data: any): string {
    // Format string can be an array, it will attempt to interpolate each item
    // in the array, if there is a failure to replace it will mark it as such
    // It will either return the first successful replacement of ALL variables,
    // or an empty string
    if (Array.isArray(formatString)) {
      let successes: string[] = [];
      let failures: string[] = [];
      formatString.forEach((format: string) => {
        let isSuccess: boolean = true;
        let attempt = format.replace(/\$([\w\.]+)/g, (original, key) => {
          let keys = key.split('.');
          let value = data[keys.shift()];
          while (keys.length && value !== undefined) {
            let k = keys.shift();
            value = k ? value[k] : `${value}.`;
          }
          if (isSuccess && Helpers.isEmpty(value)) {
            isSuccess = false;
          }
          return Helpers.isEmpty(value) ? '' : value;
        });
        if (isSuccess) {
          successes.push(attempt);
        } else {
          failures.push(attempt);
        }
      });
      if (successes.length !== 0) {
        return successes[0];
      }
      return '';
    } else {
      return Helpers.interpolate(formatString, data);
    }
  }

  /**
   * Verifies that an object has every property expected by a string to interpolate
   * @param  {String} str   The string to interpolate
   * @param  {Object} props The params to replace in string.
   * @return {Boolean}
   */
  static validateInterpolationProps(str, props) {
    let keys = str.match(/\$([\w\.]+)/g);
    return keys.every((key) => {
      return props.hasOwnProperty(key.substr(1));
    });
  }

  static isObject(item) {
    return item && typeof item === 'object' && !Array.isArray(item) && item !== null;
  }

  /**
   * Checks to see if the object is a string
   */
  static isString(obj: any) {
    return typeof obj === 'string';
  }

  static isNumber(obj: any) {
    return obj && !isNaN(parseInt(obj, 10));
  }

  /**
   * Checks to see if the object is a undefined or null
   */
  static isBlank(obj: any): boolean {
    return obj === undefined || obj === null;
  }

  /**
   * Checks to see if the object is a undefined or null
   */
  static isEmpty(obj: any): boolean {
    return Helpers.isBlank(obj) || obj === '' || (Array.isArray(obj) && obj.length === 0);
  }

  /**
   * Checks to see if the object is a function
   */
  static isFunction(obj: any): boolean {
    return !!(obj && obj.constructor && obj.call && obj.apply);
  }

  /**
   * Checks to see if the object is a Date
   */
  static isDate(obj: any) {
    return obj instanceof Date;
  }

  static sortByField(fields: any, reverse = false) {
    return (previous: any, current: any) => {
      if (Helpers.isFunction(fields)) {
        return fields(reverse ? 'desc' : 'asc', previous, current);
      }
      if (!Array.isArray(fields)) {
        fields = [fields];
      }
      for (let i = 0; i < fields.length; i++) {
        let field: string = fields[i];
        let first = previous[field] || '';
        let second = current[field] || '';

        if (Helpers.isDate(first) && Helpers.isDate(second)) {
          // Dates
          first = first.getTime();
          second = second.getTime();
        } else if (Helpers.isString(first) && Helpers.isString(second)) {
          // Basic strings
          first = first.toLowerCase();
          second = second.toLowerCase();
        } else {
          // Numbers
          first = isNaN(Number(first)) ? first : Number(first);
          second = isNaN(Number(second)) ? second : Number(second);
        }

        if (first > second) {
          return reverse ? -1 : 1;
        } else if (first < second) {
          return reverse ? 1 : -1;
        }
      }
      return 0;
    };
  }

  static filterByField(key, value) {
    return (item) => {
      let results = [];
      let field = can(item).have(key);
      if (value instanceof Function) {
        results.push(value(field, item));
      } else if (Array.isArray(value)) {
        results.push(value.includes(field));
      } else if (value instanceof Object) {
        if (field instanceof Date) {
          field = field.getTime();
        }
        if (value.min) {
          results.push(field >= value.min);
        }
        if (value.max) {
          results.push(field <= value.max);
        }
        if (value.any && Array.isArray(value.any)) {
          if (Array.isArray(field)) {
            results.push(value.any.some((v) => field.includes(v)));
          } else {
            results.push(value.any.includes(field));
          }
        }
        if (value.all && Array.isArray(value.all)) {
          results.push(value.all.every((v) => field.includes(v)));
        }
        if (value.not) {
          results.push(!Helpers.filterByField(key, value.not)(item));
        }
        for (let subkey in value) {
          if (['min', 'max', 'any', 'all', 'not'].indexOf(subkey) < 0) {
            let subvalue = value[subkey];
            results.push(Helpers.filterByField(`${key}.${subkey}`, subvalue)(item));
          }
        }
      } else {
        results.push(JSON.stringify(field).match(new RegExp(value, 'gi')));
      }
      return results.every((x) => x);
    };
  }

  static findAncestor(element: Element, selector: string): Element {
    while ((element = element.parentElement) && !element.matches.call(element, selector)) ; // tslint:disable-line
    return element;
  }

  static deepClone(item: any): any {
    if (Array.isArray(item)) {
      let newArr = [];
      for (let i = item.length; i-- > 0;) {
        // tslint:disable-line
        newArr[i] = Helpers.deepClone(item[i]);
      }
      return newArr;
    }
    if (typeof item === 'function' && !/\(\) \{ \[native/.test(item.toString())) {
      let obj;
      eval('obj = ' + item.toString()); // tslint:disable-line
      for (let k in item) {
        if (k in item) {
          obj[k] = Helpers.deepClone(item[k]);
        }
      }
      return obj;
    }
    if (item && typeof item === 'object') {
      let obj = {};
      for (let k in item) {
        if (k in item) {
          obj[k] = Helpers.deepClone(item[k]);
        }
      }
      return obj;
    }
    return item;
  }

  static deepAssign(...objs) {
    if (objs.length < 2) {
      throw new Error('Need two or more objects to merge');
    }
    const target = Object.assign({}, objs[0]);
    for (let i = 1; i < objs.length; i++) {
      const source = Object.assign({}, objs[i]);
      Object.keys(source).forEach((prop) => {
        const value = source[prop];
        if (Helpers.isObject(value)) {
          if (target.hasOwnProperty(prop) && Helpers.isObject(target[prop])) {
            target[prop] = Helpers.deepAssign(target[prop], value);
          } else {
            target[prop] = value;
          }
        } else if (Array.isArray(value)) {
          if (target.hasOwnProperty(prop) && Array.isArray(target[prop])) {
            const targetArray = target[prop];
            value.forEach((sourceItem, itemIndex) => {
              if (itemIndex < targetArray.length) {
                const targetItem = targetArray[itemIndex];
                if (Object.is(targetItem, sourceItem)) {
                  return;
                }
                if (Helpers.isObject(targetItem) && Helpers.isObject(sourceItem)) {
                  targetArray[itemIndex] = Helpers.deepAssign(targetItem, sourceItem);
                } else if (Array.isArray(targetItem) && Array.isArray(sourceItem)) {
                  targetArray[itemIndex] = Helpers.deepAssign(targetItem, sourceItem);
                } else {
                  targetArray[itemIndex] = sourceItem;
                }
              } else {
                targetArray.push(sourceItem);
              }
            });
          } else {
            target[prop] = value;
          }
        } else {
          target[prop] = value;
        }
      });
    }

    return target;
  }

  /**
   * Workaround for Edge browser since Element:nextElementSibling is undefined inside of template directives
   * @param element any document element
   * @returns the next sibling node that is of type: Element
   */
  static getNextElementSibling(element: Element): Node {
    if (element.nextElementSibling) {
      return element.nextElementSibling;
    } else {
      let e = element.nextSibling;
      while (e && 1 !== e.nodeType) {
        e = e.nextSibling;
      }
      return e;
    }
  }
}

export class Can {
  obj: Object;

  constructor(obj: Object) {
    this.obj = obj;
  }

  have(key: string): any {
    let props = key.split('.');
    let item: any = this.obj;
    for (let i = 0; i < props.length; i++) {
      item = item[props[i]];
      if (this.check(item) === false) {
        return item;
      }
    }
    return item;
  }

  check(thing: any): boolean {
    return thing !== void 0;
  }
}

/**
 * @param {any} obj
 * @returns
 */
export function can(obj) {
  return new Can(obj);
}

1	export class Helpers {	1✔
2	/**
3	* Swallows an event to stop further execution
4	* @param event
5	*/
6	static swallowEvent(event) {	1✔
7	if (event) {	16✔
8	event.stopPropagation();	2✔
9	event.preventDefault();	2✔
10	}
11	}
12
13	static interpolate(str: string, props: any): string {	1✔
14	return str.replace(/\$([\w\.]+)/g, (original, key) => {	6✔
15	let keys = key.split('.');	8✔
16	let value = props[keys.shift()];	8✔
17	while (keys.length && value !== undefined) {	8!
18	let k = keys.shift();	×
19	value = k ? value[k] : `${value}.`;	×
20	}
21	return value !== undefined ? value : '';	8✔
22	});
23	}
24
25	static interpolateWithFallback(formatString: string \| string[], data: any): string {	1✔
26	// Format string can be an array, it will attempt to interpolate each item
27	// in the array, if there is a failure to replace it will mark it as such
28	// It will either return the first successful replacement of ALL variables,
29	// or an empty string
30	if (Array.isArray(formatString)) {	×
31	let successes: string[] = [];	×
32	let failures: string[] = [];	×
33	formatString.forEach((format: string) => {	×
34	let isSuccess: boolean = true;	×
35	let attempt = format.replace(/\$([\w\.]+)/g, (original, key) => {	×
36	let keys = key.split('.');	×
37	let value = data[keys.shift()];	×
38	while (keys.length && value !== undefined) {	×
39	let k = keys.shift();	×
40	value = k ? value[k] : `${value}.`;	×
41	}
42	if (isSuccess && Helpers.isEmpty(value)) {	×
43	isSuccess = false;	×
44	}
45	return Helpers.isEmpty(value) ? '' : value;	×
46	});
47	if (isSuccess) {	×
48	successes.push(attempt);	×
49	} else {
50	failures.push(attempt);	×
51	}
52	});
53	if (successes.length !== 0) {	×
54	return successes[0];	×
55	}
56	return '';	×
57	} else {
58	return Helpers.interpolate(formatString, data);	×
59	}
60	}
61
62	/**
63	* Verifies that an object has every property expected by a string to interpolate
64	* @param {String} str The string to interpolate
65	* @param {Object} props The params to replace in string.
66	* @return {Boolean}
67	*/
68	static validateInterpolationProps(str, props) {	1✔
69	let keys = str.match(/\$([\w\.]+)/g);	2✔
70	return keys.every((key) => {	2✔
71	return props.hasOwnProperty(key.substr(1));	2✔
72	});
73	}
74
75	static isObject(item) {	1✔
76	return item && typeof item === 'object' && !Array.isArray(item) && item !== null;	×
77	}
78
79	/**
80	* Checks to see if the object is a string
81	*/
82	static isString(obj: any) {	1✔
83	return typeof obj === 'string';	13✔
84	}
85
86	static isNumber(obj: any) {	1✔
87	return obj && !isNaN(parseInt(obj, 10));	×
88	}
89
90	/**
91	* Checks to see if the object is a undefined or null
92	*/
93	static isBlank(obj: any): boolean {	1✔
94	return obj === undefined \|\| obj === null;	608✔
95	}
96
97	/**
98	* Checks to see if the object is a undefined or null
99	*/
100	static isEmpty(obj: any): boolean {	1✔
101	return Helpers.isBlank(obj) \|\| obj === '' \|\| (Array.isArray(obj) && obj.length === 0);	255✔
102	}
103
104	/**
105	* Checks to see if the object is a function
106	*/
107	static isFunction(obj: any): boolean {	1✔
108	return !!(obj && obj.constructor && obj.call && obj.apply);	29!
109	}
110
111	/**
112	* Checks to see if the object is a Date
113	*/
114	static isDate(obj: any) {	1✔
115	return obj instanceof Date;	5✔
116	}
117
118	static sortByField(fields: any, reverse = false) {	5✔
119	return (previous: any, current: any) => {	3✔
120	if (Helpers.isFunction(fields)) {	×
121	return fields(reverse ? 'desc' : 'asc', previous, current);	×
122	}
123	if (!Array.isArray(fields)) {	×
124	fields = [fields];	×
125	}
126	for (let i = 0; i < fields.length; i++) {	×
127	let field: string = fields[i];	×
128	let first = previous[field] \|\| '';	×
129	let second = current[field] \|\| '';	×
130
131	if (Helpers.isDate(first) && Helpers.isDate(second)) {	×
132	// Dates
133	first = first.getTime();	×
134	second = second.getTime();	×
135	} else if (Helpers.isString(first) && Helpers.isString(second)) {	×
136	// Basic strings
137	first = first.toLowerCase();	×
138	second = second.toLowerCase();	×
139	} else {
140	// Numbers
141	first = isNaN(Number(first)) ? first : Number(first);	×
142	second = isNaN(Number(second)) ? second : Number(second);	×
143	}
144
145	if (first > second) {	×
146	return reverse ? -1 : 1;	×
147	} else if (first < second) {	×
148	return reverse ? 1 : -1;	×
149	}
150	}
151	return 0;	×
152	};
153	}
154
155	static filterByField(key, value) {	1✔
156	return (item) => {	1✔
157	let results = [];	×
158	let field = can(item).have(key);	×
159	if (value instanceof Function) {	×
160	results.push(value(field, item));	×
161	} else if (Array.isArray(value)) {	×
162	results.push(value.includes(field));	×
163	} else if (value instanceof Object) {	×
164	if (field instanceof Date) {	×
165	field = field.getTime();	×
166	}
167	if (value.min) {	×
168	results.push(field >= value.min);	×
169	}
170	if (value.max) {	×
171	results.push(field <= value.max);	×
172	}
173	if (value.any && Array.isArray(value.any)) {	×
174	if (Array.isArray(field)) {	×
175	results.push(value.any.some((v) => field.includes(v)));	×
176	} else {
177	results.push(value.any.includes(field));	×
178	}
179	}
180	if (value.all && Array.isArray(value.all)) {	×
181	results.push(value.all.every((v) => field.includes(v)));	×
182	}
183	if (value.not) {	×
184	results.push(!Helpers.filterByField(key, value.not)(item));	×
185	}
186	for (let subkey in value) {	×
187	if (['min', 'max', 'any', 'all', 'not'].indexOf(subkey) < 0) {	×
188	let subvalue = value[subkey];	×
189	results.push(Helpers.filterByField(`${key}.${subkey}`, subvalue)(item));	×
190	}
191	}
192	} else {
193	results.push(JSON.stringify(field).match(new RegExp(value, 'gi')));	×
194	}
195	return results.every((x) => x);	×
196	};
197	}
198
199	static findAncestor(element: Element, selector: string): Element {	1✔
200	while ((element = element.parentElement) && !element.matches.call(element, selector)) ; // tslint:disable-line	×
201	return element;	×
202	}
203
204	static deepClone(item: any): any {	1✔
205	if (Array.isArray(item)) {	42✔
206	let newArr = [];	10✔
207	for (let i = item.length; i-- > 0;) {	10✔
208	// tslint:disable-line
209	newArr[i] = Helpers.deepClone(item[i]);	22✔
210	}
211	return newArr;	10✔
212	}
213	if (typeof item === 'function' && !/\(\) \{ \[native/.test(item.toString())) {	32!
214	let obj;	×
215	eval('obj = ' + item.toString()); // tslint:disable-line	×
216	for (let k in item) {	×
217	if (k in item) {	×
218	obj[k] = Helpers.deepClone(item[k]);	×
219	}
220	}
221	return obj;	×
222	}
223	if (item && typeof item === 'object') {	32✔
224	let obj = {};	10✔
225	for (let k in item) {	10✔
226	if (k in item) {	10!
227	obj[k] = Helpers.deepClone(item[k]);	10✔
228	}
229	}
230	return obj;	10✔
231	}
232	return item;	22✔
233	}
234
235	static deepAssign(...objs) {	1✔
236	if (objs.length < 2) {	×
237	throw new Error('Need two or more objects to merge');	×
238	}
239	const target = Object.assign({}, objs[0]);	×
240	for (let i = 1; i < objs.length; i++) {	×
241	const source = Object.assign({}, objs[i]);	×
242	Object.keys(source).forEach((prop) => {	×
243	const value = source[prop];	×
244	if (Helpers.isObject(value)) {	×
245	if (target.hasOwnProperty(prop) && Helpers.isObject(target[prop])) {	×
246	target[prop] = Helpers.deepAssign(target[prop], value);	×
247	} else {
248	target[prop] = value;	×
249	}
250	} else if (Array.isArray(value)) {	×
251	if (target.hasOwnProperty(prop) && Array.isArray(target[prop])) {	×
252	const targetArray = target[prop];	×
253	value.forEach((sourceItem, itemIndex) => {	×
254	if (itemIndex < targetArray.length) {	×
255	const targetItem = targetArray[itemIndex];	×
256	if (Object.is(targetItem, sourceItem)) {	×
257	return;	×
258	}
259	if (Helpers.isObject(targetItem) && Helpers.isObject(sourceItem)) {	×
260	targetArray[itemIndex] = Helpers.deepAssign(targetItem, sourceItem);	×
261	} else if (Array.isArray(targetItem) && Array.isArray(sourceItem)) {	×
262	targetArray[itemIndex] = Helpers.deepAssign(targetItem, sourceItem);	×
263	} else {
264	targetArray[itemIndex] = sourceItem;	×
265	}
266	} else {
267	targetArray.push(sourceItem);	×
268	}
269	});
270	} else {
271	target[prop] = value;	×
272	}
273	} else {
274	target[prop] = value;	×
275	}
276	});
277	}
278
279	return target;	×
280	}
281
282	/**
283	* Workaround for Edge browser since Element:nextElementSibling is undefined inside of template directives
284	* @param element any document element
285	* @returns the next sibling node that is of type: Element
286	*/
287	static getNextElementSibling(element: Element): Node {	1✔
288	if (element.nextElementSibling) {	3✔
289	return element.nextElementSibling;	2✔
290	} else {
291	let e = element.nextSibling;	1✔
292	while (e && 1 !== e.nodeType) {	1!
293	e = e.nextSibling;	×
294	}
295	return e;	1✔
296	}
297	}
298	}	1✔
299
300	export class Can {	1✔
301	obj: Object;
302
303	constructor(obj: Object) {
304	this.obj = obj;	×
305	}
306
307	have(key: string): any {	1✔
308	let props = key.split('.');	×
309	let item: any = this.obj;	×
310	for (let i = 0; i < props.length; i++) {	×
311	item = item[props[i]];	×
312	if (this.check(item) === false) {	×
313	return item;	×
314	}
315	}
316	return item;	×
317	}
318
319	check(thing: any): boolean {	1✔
320	return thing !== void 0;	×
321	}
322	}	1✔
323
324	/**
325	* @param {any} obj
326	* @returns
327	*/
328	export function can(obj) {	1✔
329	return new Can(obj);	×
330	}

bullhorn / novo-elements / 4066

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous