8286875510

Committed 14 Mar 2024 08:03PM UTC coverage: 65.272% (+0.08%) from 65.192%

Build # 8286875510

Build Type

Pull #841

github

Committed by

web-flow

Commit Message

Merge 35839ef73 into 3ec3b5a03

Pull Request Pull Request #841: Read creation date from XMP sidecar too

Run Details

1543 of 2681 branches covered (57.55%)

Branch coverage included in aggregate %.

74 of 77 new or added lines in 2 files covered. (96.1%)

1 existing line in 1 file now uncovered.

4387 of 6404 relevant lines covered (68.5%)

13453.28 hits per line

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

57.36

/src/common/Utils.ts

export class Utils {
  static GUID(): string {
    const s4 = (): string =>
      Math.floor((1 + Math.random()) * 0x10000)
        .toString(16)
        .substring(1);

    return s4() + s4() + '-' + s4() + s4();
  }

  static chunkArrays<T>(arr: T[], chunkSize: number): T[][] {
    const R = [];
    for (let i = 0; i < arr.length; i += chunkSize) {
      R.push(arr.slice(i, i + chunkSize));
    }
    return R;
  }

  static wait(time: number): Promise<unknown> {
    return new Promise((resolve): void => {
      setTimeout(resolve, time);
    });
  }

  static removeNullOrEmptyObj<T extends { [key: string]: any }>(obj: T): T {
    if (typeof obj !== 'object' || obj == null) {
      return obj;
    }

    const keys = Object.keys(obj);
    for (const key of keys) {
      if (obj[key] !== null && typeof obj[key] === 'object') {
        if (Utils.removeNullOrEmptyObj(obj[key])) {
          if (Object.keys(obj[key]).length === 0) {
            delete obj[key];
          }
        }
      } else if (obj[key] === null) {
        delete obj[key];
      }
    }
    return obj;
  }

  static clone<T>(object: T): T {
    return JSON.parse(JSON.stringify(object));
  }

  static shallowClone<T>(object: T): T {
    const c: any = {};
    for (const e of Object.entries(object)) {
      c[e[0]] = e[1];
    }
    return c;
  }

  static zeroPrefix(value: string | number, length: number): string {
    const ret = '00000' + value;
    return ret.substr(ret.length - length);
  }

  /**
   * Checks if the two input (let them be objects or arrays or just primitives) are equal
   */
  static equalsFilter(object: any, filter: any, skipProp: string[] = []): boolean {
    if (typeof filter !== 'object' || filter == null) {
      return object === filter;
    }
    if (!object) {
      return false;
    }

    if (Array.isArray(object) && object.length !== filter.length) {
      return false;
    }
    const keys = Object.keys(filter);
    for (const key of keys) {
      if (skipProp.includes(key)) {
        continue;
      }
      if (typeof filter[key] === 'object') {
        if (Utils.equalsFilter(object[key], filter[key], skipProp) === false) {
          return false;
        }
      } else if (object[key] !== filter[key]) {
        return false;
      }
    }

    return true;
  }

  static toIsoString(d: number | Date) {
    if (!(d instanceof Date)) {
      d = new Date(d);
    }
    return d.getUTCFullYear() + '-' + d.getUTCMonth() + '-' + d.getUTCDate();
  }


  static makeUTCMidnight(d: number | Date) {
    if (!(d instanceof Date)) {
      d = new Date(d);
    }
    d.setUTCHours(0);
    d.setUTCMinutes(0);
    d.setUTCSeconds(0);
    d.setUTCMilliseconds(0);

    return d;
  }

  static getUTCFullYear(d: number | Date, offset: string) {
    if (!(d instanceof Date)) {
      d = new Date(d);
    }
    return new Date(new Date(d).toISOString().substring(0,19) + (offset ? offset : '')).getUTCFullYear();
  }

  static getFullYear(d: number | Date, offset: string) {
    if (!(d instanceof Date)) {
      d = new Date(d);
    }
    return new Date(new Date(d).toISOString().substring(0,19) + (offset ? offset : '')).getFullYear();
  }

  //function to convert timestamp into milliseconds taking offset into account
  static timestampToMS(timestamp: string, offset: string) {
    if (!timestamp) {
      return undefined;
    }
    //replace : with - in the yyyy-mm-dd part of the timestamp.
    let formattedTimestamp = timestamp.substring(0,9).replaceAll(':', '-') + timestamp.substring(9,timestamp.length);
    if (formattedTimestamp.indexOf("Z") > 0) { //replace Z (and what comes after the Z) with offset
      formattedTimestamp.substring(0, formattedTimestamp.indexOf("Z")) + (offset ? offset : '+00:00');
    } else if (formattedTimestamp.indexOf("+") > 0) { //don't do anything
    } else { //add offset
      formattedTimestamp = formattedTimestamp + (offset ? offset : '+00:00');
    }
    //parse into MS and return
    return Date.parse(formattedTimestamp);
  }

  //function to calculate offset from exif.exif.gpsTimeStamp or exif.gps.GPSDateStamp + exif.gps.GPSTimestamp
  static getTimeOffsetByGPSStamp(timestamp: string, gpsTimeStamp: string, gps: any) {
    let UTCTimestamp = gpsTimeStamp;
    if (!UTCTimestamp &&
      gps &&
      gps.GPSDateStamp &&
      gps.GPSTimeStamp) { //else use exif.gps.GPS*Stamp if available
      //GPS timestamp is always UTC (+00:00)
      UTCTimestamp = gps.GPSDateStamp.replaceAll(':', '-') + gps.GPSTimeStamp.join(':');
    }
    if (UTCTimestamp && timestamp) {
      //offset in minutes is the difference between gps timestamp and given timestamp
      //to calculate this correctly, we have to work with the same offset
      const offsetMinutes = (Utils.timestampToMS(timestamp, '+00:00')- Utils.timestampToMS(UTCTimestamp, '+00:00')) / 1000 / 60;
      return Utils.getOffsetString(offsetMinutes);
    } else {
      return undefined;
    }
  }

  static getOffsetString(offsetMinutes: number) {
    if (-720 <= offsetMinutes && offsetMinutes <= 840) {
      //valid offset is within -12 and +14 hrs (https://en.wikipedia.org/wiki/List_of_UTC_offsets)
      return (offsetMinutes < 0 ? "-" : "+") +                              //leading +/-
        ("0" + Math.trunc(Math.abs(offsetMinutes) / 60)).slice(-2) + ":" +  //zeropadded hours and ':'
        ("0" + Math.abs(offsetMinutes) % 60).slice(-2);                     //zeropadded minutes
    } else {
      return undefined;
    }
  }

  static getOffsetMinutes(offsetString: string) { //Convert offset string (+HH:MM or -HH:MM) into a minute value
    const regex = /^([+-](0[0-9]|1[0-4]):[0-5][0-9])$/;  //checks if offset is between -14:00 and +14:00. 
                                                         //-12:00 is the lowest valid UTC-offset, but we allow down to -14 for efficiency
    if (regex.test(offsetString)) {
      const hhmm = offsetString.split(":");
      const hours = parseInt(hhmm[0]);
      return hours < 0 ? ((hours*60) - parseInt(hhmm[1])) : ((hours*60) + parseInt(hhmm[1]));
    } else {
      return undefined;
    }
  }

  static isLeapYear(year: number) {
    return (0 == year % 4) && (0 != year % 100) || (0 == year % 400)
  }

  static isDateFromLeapYear(date: Date) {
    return Utils.isLeapYear(date.getFullYear());
  }

  // Get Day of Year
  static getDayOfYear(date: Date) {
    //Day-number at the start of Jan to Dec. A month baseline
    const dayCount = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
    const mn = date.getMonth();
    let dayOfYear = dayCount[mn] + date.getDate(); //add the date to the month baseline
    if (mn > 1 && Utils.isLeapYear((date.getFullYear()))) {
      dayOfYear++; //Add an extra day for march to december (mn>1) on leap years
    }
    return dayOfYear;
  }

  static renderDataSize(size: number): string {
    const postFixes = ['B', 'KB', 'MB', 'GB', 'TB'];
    let index = 0;
    while (size > 1000 && index < postFixes.length - 1) {
      size /= 1000;
      index++;
    }
    return size.toFixed(2) + postFixes[index];
  }

  static getUnique(arr: any[]) {
    return arr.filter((value, index, arr) => arr.indexOf(value) === index);
  }

  static createRange(from: number, to: number): Array<number> {
    const arr = new Array(to - from + 1);
    let c = to - from + 1;
    while (c--) {
      arr[c] = to--;
    }
    return arr;
  }

  public static canonizePath(path: string): string {
    return path
      .replace(new RegExp('\\\\', 'g'), '/')
      .replace(new RegExp('/+', 'g'), '/');
  }

  static concatUrls(...args: string[]): string {
    let url = '';
    for (const item of args) {
      if (item === '' || typeof item === 'undefined') {
        continue;
      }

      const part = item.replace(new RegExp('\\\\', 'g'), '/');
      if (part === '/' || part === './') {
        continue;
      }

      url += part + '/';
    }
    url = url.replace(/(https?:\/\/)|(\/){2,}/g, '$1$2');

    if (url.trim() === '') {
      url = './';
    }

    return url.substring(0, url.length - 1);
  }

  public static updateKeys(targetObject: any, sourceObject: any): void {
    Object.keys(sourceObject).forEach((key): void => {
      if (typeof targetObject[key] === 'undefined') {
        return;
      }
      if (typeof targetObject[key] === 'object') {
        Utils.updateKeys(targetObject[key], sourceObject[key]);
      } else {
        targetObject[key] = sourceObject[key];
      }
    });
  }

  public static setKeys(targetObject: any, sourceObject: any): void {
    Object.keys(sourceObject).forEach((key): void => {
      if (typeof targetObject[key] === 'object') {
        Utils.setKeys(targetObject[key], sourceObject[key]);
      } else {
        targetObject[key] = sourceObject[key];
      }
    });
  }

  public static setKeysForced(targetObject: any, sourceObject: any): void {
    Object.keys(sourceObject).forEach((key): void => {
      if (typeof sourceObject[key] === 'object') {
        if (typeof targetObject[key] === 'undefined') {
          targetObject[key] = {};
        }
        Utils.setKeysForced(targetObject[key], sourceObject[key]);
      } else {
        targetObject[key] = sourceObject[key];
      }
    });
  }

  public static isValidEnumInt(EnumType: any, value: number) {
    return typeof EnumType[value] === 'string';
  }

  public static enumToArray(EnumType: any): { key: number; value: string }[] {
    const arr: Array<{ key: number; value: string }> = [];
    for (const enumMember in EnumType) {
      // eslint-disable-next-line no-prototype-builtins
      if (!EnumType.hasOwnProperty(enumMember)) {
        continue;
      }
      const key = parseInt(enumMember, 10);
      if (key >= 0) {
        arr.push({key, value: EnumType[enumMember]});
      }
    }
    return arr;
  }

  public static findClosest(num: number, arr: number[]): number {
    let curr = arr[0];
    let diff = Math.abs(num - curr);

    arr.forEach((value): void => {
      const newDiff = Math.abs(num - value);

      if (newDiff < diff) {
        diff = newDiff;
        curr = value;
      }
    });

    return curr;
  }

  public static findClosestinSorted(num: number, arr: number[]): number {
    let curr = arr[0];
    let diff = Math.abs(num - curr);
    for (const item of arr) {
      const newDiff = Math.abs(num - item);
      if (newDiff > diff) {
        break;
      }
      diff = newDiff;
      curr = item;
    }

    return curr;
  }

  public static isUInt32(value: number, max = 4294967295): boolean {
    value = parseInt('' + value, 10);
    return !isNaN(value) && value >= 0 && value <= max;
  }

  public static isInt32(value: number): boolean {
    value = parseFloat('' + value);
    return !isNaN(value) && value >= -2147483648 && value <= 2147483647;
  }

  public static isFloat32(value: number): boolean {
    const E = Math.pow(10, 38);
    const nE = Math.pow(10, -38);
    return (
      !isNaN(value) &&
      ((value >= -3.402823466 * E && value <= -1.175494351 * nE) ||
        (value <= 3.402823466 * E && value >= 1.175494351 * nE))
    );
  }

  public static getAnyX(num: number, arr: any[], start = 0): any[][] {
    if (num <= 0 || num > arr.length || start >= arr.length) {
      return [];
    }
    if (num <= 1) {
      return arr.slice(start).map((e): any[] => [e]);
    }
    if (num === arr.length - start) {
      return [arr.slice(start)];
    }
    const ret: any[][] = [];
    for (let i = start; i < arr.length; ++i) {
      Utils.getAnyX(num - 1, arr, i + 1).forEach((a): void => {
        a.push(arr[i]);
        ret.push(a);
      });
    }
    return ret;
  }
}

export class LRU<V> {
  data: { [key: string]: { value: V; usage: number } } = {};

  constructor(public readonly size: number) {
  }

  set(key: string, value: V): void {
    this.data[key] = {usage: Date.now(), value};
    if (Object.keys(this.data).length > this.size) {
      let oldestK = key;
      let oldest = this.data[oldestK].usage;
      for (const k in this.data) {
        if (this.data[k].usage < oldest) {
          oldestK = k;
          oldest = this.data[oldestK].usage;
        }
      }
      delete this.data[oldestK];
    }
  }

  get(key: string): V {
    if (!this.data[key]) {
      return;
    }
    return this.data[key].value;
  }
}

1	export class Utils {	1✔
2	static GUID(): string {
3	const s4 = (): string =>	×
4	Math.floor((1 + Math.random()) * 0x10000)	×
5	.toString(16)
6	.substring(1);
7
8	return s4() + s4() + '-' + s4() + s4();	×
9	}
10
11	static chunkArrays<T>(arr: T[], chunkSize: number): T[][] {
12	const R = [];	×
13	for (let i = 0; i < arr.length; i += chunkSize) {	×
14	R.push(arr.slice(i, i + chunkSize));	×
15	}
16	return R;	×
17	}
18
19	static wait(time: number): Promise<unknown> {
20	return new Promise((resolve): void => {	×
21	setTimeout(resolve, time);	×
22	});
23	}
24
25	static removeNullOrEmptyObj<T extends { [key: string]: any }>(obj: T): T {
26	if (typeof obj !== 'object' \|\| obj == null) {	2,139!
27	return obj;	×
28	}
29
30	const keys = Object.keys(obj);	2,139✔
31	for (const key of keys) {	2,139✔
32	if (obj[key] !== null && typeof obj[key] === 'object') {	8,064✔
33	if (Utils.removeNullOrEmptyObj(obj[key])) {	1,955!
34	if (Object.keys(obj[key]).length === 0) {	1,955✔
35	delete obj[key];	249✔
36	}
37	}
38	} else if (obj[key] === null) {	6,109✔
39	delete obj[key];	926✔
40	}
41	}
42	return obj;	2,139✔
43	}
44
45	static clone<T>(object: T): T {
46	return JSON.parse(JSON.stringify(object));	4,990✔
47	}
48
49	static shallowClone<T>(object: T): T {
50	const c: any = {};	×
51	for (const e of Object.entries(object)) {	×
52	c[e[0]] = e[1];	×
53	}
54	return c;	×
55	}
56
57	static zeroPrefix(value: string \| number, length: number): string {
58	const ret = '00000' + value;	×
59	return ret.substr(ret.length - length);	×
60	}
61
62	/**
63	* Checks if the two input (let them be objects or arrays or just primitives) are equal
64	*/
65	static equalsFilter(object: any, filter: any, skipProp: string[] = []): boolean {	102✔
66	if (typeof filter !== 'object' \|\| filter == null) {	170✔
67	return object === filter;	23✔
68	}
69	if (!object) {	147✔
70	return false;	12✔
71	}
72
73	if (Array.isArray(object) && object.length !== filter.length) {	135!
74	return false;	×
75	}
76	const keys = Object.keys(filter);	135✔
77	for (const key of keys) {	135✔
78	if (skipProp.includes(key)) {	430!
79	continue;	×
80	}
81	if (typeof filter[key] === 'object') {	430✔
82	if (Utils.equalsFilter(object[key], filter[key], skipProp) === false) {	68✔
83	return false;	12✔
84	}
85	} else if (object[key] !== filter[key]) {	362✔
86	return false;	17✔
87	}
88	}
89
90	return true;	106✔
91	}
92
93	static toIsoString(d: number \| Date) {
94	if (!(d instanceof Date)) {	×
95	d = new Date(d);	×
96	}
97	return d.getUTCFullYear() + '-' + d.getUTCMonth() + '-' + d.getUTCDate();	×
98	}
99
100
101	static makeUTCMidnight(d: number \| Date) {
102	if (!(d instanceof Date)) {	×
103	d = new Date(d);	×
104	}
105	d.setUTCHours(0);	×
106	d.setUTCMinutes(0);	×
107	d.setUTCSeconds(0);	×
108	d.setUTCMilliseconds(0);	×
109
110	return d;	×
111	}
112
113	static getUTCFullYear(d: number \| Date, offset: string) {
114	if (!(d instanceof Date)) {	×
115	d = new Date(d);	×
116	}
117	return new Date(new Date(d).toISOString().substring(0,19) + (offset ? offset : '')).getUTCFullYear();	×
118	}
119
120	static getFullYear(d: number \| Date, offset: string) {
121	if (!(d instanceof Date)) {	×
122	d = new Date(d);	×
123	}
124	return new Date(new Date(d).toISOString().substring(0,19) + (offset ? offset : '')).getFullYear();	×
125	}
126
127	//function to convert timestamp into milliseconds taking offset into account
128	static timestampToMS(timestamp: string, offset: string) {
129	if (!timestamp) {	273!
NEW 130	return undefined;	×
131	}
132	//replace : with - in the yyyy-mm-dd part of the timestamp.
133	let formattedTimestamp = timestamp.substring(0,9).replaceAll(':', '-') + timestamp.substring(9,timestamp.length);	273✔
134	if (formattedTimestamp.indexOf("Z") > 0) { //replace Z (and what comes after the Z) with offset	273✔
135	formattedTimestamp.substring(0, formattedTimestamp.indexOf("Z")) + (offset ? offset : '+00:00');	11!
136	} else if (formattedTimestamp.indexOf("+") > 0) { //don't do anything	262✔
137	} else { //add offset
138	formattedTimestamp = formattedTimestamp + (offset ? offset : '+00:00');	220✔
139	}
140	//parse into MS and return
141	return Date.parse(formattedTimestamp);	273✔
142	}
143
144	//function to calculate offset from exif.exif.gpsTimeStamp or exif.gps.GPSDateStamp + exif.gps.GPSTimestamp
145	static getTimeOffsetByGPSStamp(timestamp: string, gpsTimeStamp: string, gps: any) {
146	let UTCTimestamp = gpsTimeStamp;	112✔
147	if (!UTCTimestamp &&	112✔
148	gps &&
149	gps.GPSDateStamp &&
150	gps.GPSTimeStamp) { //else use exif.gps.GPS*Stamp if available
151	//GPS timestamp is always UTC (+00:00)
152	UTCTimestamp = gps.GPSDateStamp.replaceAll(':', '-') + gps.GPSTimeStamp.join(':');	13✔
153	}
154	if (UTCTimestamp && timestamp) {	112✔
155	//offset in minutes is the difference between gps timestamp and given timestamp
156	//to calculate this correctly, we have to work with the same offset
157	const offsetMinutes = (Utils.timestampToMS(timestamp, '+00:00')- Utils.timestampToMS(UTCTimestamp, '+00:00')) / 1000 / 60;	25✔
158	return Utils.getOffsetString(offsetMinutes);	25✔
159	} else {
160	return undefined;	87✔
161	}
162	}
163
164	static getOffsetString(offsetMinutes: number) {
165	if (-720 <= offsetMinutes && offsetMinutes <= 840) {	3,736✔
166	//valid offset is within -12 and +14 hrs (https://en.wikipedia.org/wiki/List_of_UTC_offsets)
167	return (offsetMinutes < 0 ? "-" : "+") + //leading +/-	3,713✔
168	("0" + Math.trunc(Math.abs(offsetMinutes) / 60)).slice(-2) + ":" + //zeropadded hours and ':'
169	("0" + Math.abs(offsetMinutes) % 60).slice(-2); //zeropadded minutes
170	} else {
171	return undefined;	23✔
172	}
173	}
174
175	static getOffsetMinutes(offsetString: string) { //Convert offset string (+HH:MM or -HH:MM) into a minute value
176	const regex = /^([+-](0[0-9]\|1[0-4]):[0-5][0-9])$/; //checks if offset is between -14:00 and +14:00.	3,412✔
177	//-12:00 is the lowest valid UTC-offset, but we allow down to -14 for efficiency
178	if (regex.test(offsetString)) {	3,412✔
179	const hhmm = offsetString.split(":");	3,262✔
180	const hours = parseInt(hhmm[0]);	3,262✔
181	return hours < 0 ? ((hours60) - parseInt(hhmm[1])) : ((hours60) + parseInt(hhmm[1]));	3,262✔
182	} else {
183	return undefined;	150✔
184	}
185	}
186
187	static isLeapYear(year: number) {
188	return (0 == year % 4) && (0 != year % 100) \|\| (0 == year % 400)	44!
189	}
190
191	static isDateFromLeapYear(date: Date) {
192	return Utils.isLeapYear(date.getFullYear());	28✔
193	}
194
195	// Get Day of Year
196	static getDayOfYear(date: Date) {
197	//Day-number at the start of Jan to Dec. A month baseline
198	const dayCount = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];	16✔
199	const mn = date.getMonth();	16✔
200	let dayOfYear = dayCount[mn] + date.getDate(); //add the date to the month baseline	16✔
201	if (mn > 1 && Utils.isLeapYear((date.getFullYear()))) {	16!
202	dayOfYear++; //Add an extra day for march to december (mn>1) on leap years	16✔
203	}
204	return dayOfYear;	16✔
205	}
206
207	static renderDataSize(size: number): string {
208	const postFixes = ['B', 'KB', 'MB', 'GB', 'TB'];	×
209	let index = 0;	×
210	while (size > 1000 && index < postFixes.length - 1) {	×
211	size /= 1000;	×
212	index++;	×
213	}
214	return size.toFixed(2) + postFixes[index];	×
215	}
216
217	static getUnique(arr: any[]) {
218	return arr.filter((value, index, arr) => arr.indexOf(value) === index);	×
219	}
220
221	static createRange(from: number, to: number): Array<number> {
222	const arr = new Array(to - from + 1);	×
223	let c = to - from + 1;	×
224	while (c--) {	×
225	arr[c] = to--;	×
226	}
227	return arr;	×
228	}
229
230	public static canonizePath(path: string): string {
231	return path	75✔
232	.replace(new RegExp('\\\\', 'g'), '/')
233	.replace(new RegExp('/+', 'g'), '/');
234	}
235
236	static concatUrls(...args: string[]): string {
237	let url = '';	22✔
238	for (const item of args) {	22✔
239	if (item === '' \|\| typeof item === 'undefined') {	46!
240	continue;	×
241	}
242
243	const part = item.replace(new RegExp('\\\\', 'g'), '/');	46✔
244	if (part === '/' \|\| part === './') {	46✔
245	continue;	5✔
246	}
247
248	url += part + '/';	41✔
249	}
250	url = url.replace(/(https?:\/\/)\|(\/){2,}/g, '$1$2');	22✔
251
252	if (url.trim() === '') {	22✔
253	url = './';	1✔
254	}
255
256	return url.substring(0, url.length - 1);	22✔
257	}
258
259	public static updateKeys(targetObject: any, sourceObject: any): void {
260	Object.keys(sourceObject).forEach((key): void => {	×
261	if (typeof targetObject[key] === 'undefined') {	×
262	return;	×
263	}
264	if (typeof targetObject[key] === 'object') {	×
265	Utils.updateKeys(targetObject[key], sourceObject[key]);	×
266	} else {
267	targetObject[key] = sourceObject[key];	×
268	}
269	});
270	}
271
272	public static setKeys(targetObject: any, sourceObject: any): void {
273	Object.keys(sourceObject).forEach((key): void => {	×
274	if (typeof targetObject[key] === 'object') {	×
275	Utils.setKeys(targetObject[key], sourceObject[key]);	×
276	} else {
277	targetObject[key] = sourceObject[key];	×
278	}
279	});
280	}
281
282	public static setKeysForced(targetObject: any, sourceObject: any): void {
283	Object.keys(sourceObject).forEach((key): void => {	×
284	if (typeof sourceObject[key] === 'object') {	×
285	if (typeof targetObject[key] === 'undefined') {	×
286	targetObject[key] = {};	×
287	}
288	Utils.setKeysForced(targetObject[key], sourceObject[key]);	×
289	} else {
290	targetObject[key] = sourceObject[key];	×
291	}
292	});
293	}
294
295	public static isValidEnumInt(EnumType: any, value: number) {
296	return typeof EnumType[value] === 'string';	6✔
297	}
298
299	public static enumToArray(EnumType: any): { key: number; value: string }[] {
300	const arr: Array<{ key: number; value: string }> = [];	1✔
301	for (const enumMember in EnumType) {	1✔
302	// eslint-disable-next-line no-prototype-builtins
303	if (!EnumType.hasOwnProperty(enumMember)) {	12!
304	continue;	×
305	}
306	const key = parseInt(enumMember, 10);	12✔
307	if (key >= 0) {	12✔
308	arr.push({key, value: EnumType[enumMember]});	6✔
309	}
310	}
311	return arr;	1✔
312	}
313
314	public static findClosest(num: number, arr: number[]): number {
315	let curr = arr[0];	4✔
316	let diff = Math.abs(num - curr);	4✔
317
318	arr.forEach((value): void => {	4✔
319	const newDiff = Math.abs(num - value);	10✔
320
321	if (newDiff < diff) {	10!
322	diff = newDiff;	×
323	curr = value;	×
324	}
325	});
326
327	return curr;	4✔
328	}
329
330	public static findClosestinSorted(num: number, arr: number[]): number {
331	let curr = arr[0];	6✔
332	let diff = Math.abs(num - curr);	6✔
333	for (const item of arr) {	6✔
334	const newDiff = Math.abs(num - item);	19✔
335	if (newDiff > diff) {	19✔
336	break;	5✔
337	}
338	diff = newDiff;	14✔
339	curr = item;	14✔
340	}
341
342	return curr;	6✔
343	}
344
345	public static isUInt32(value: number, max = 4294967295): boolean {	196✔
346	value = parseInt('' + value, 10);	196✔
347	return !isNaN(value) && value >= 0 && value <= max;	196✔
348	}
349
350	public static isInt32(value: number): boolean {
351	value = parseFloat('' + value);	205✔
352	return !isNaN(value) && value >= -2147483648 && value <= 2147483647;	205✔
353	}
354
355	public static isFloat32(value: number): boolean {
356	const E = Math.pow(10, 38);	746✔
357	const nE = Math.pow(10, -38);	746✔
358	return (	746✔
359	!isNaN(value) &&	2,370✔
360	((value >= -3.402823466 * E && value <= -1.175494351 * nE) \|\|
361	(value <= 3.402823466 * E && value >= 1.175494351 * nE))
362	);
363	}
364
365	public static getAnyX(num: number, arr: any[], start = 0): any[][] {	×
366	if (num <= 0 \|\| num > arr.length \|\| start >= arr.length) {	×
367	return [];	×
368	}
369	if (num <= 1) {	×
370	return arr.slice(start).map((e): any[] => [e]);	×
371	}
372	if (num === arr.length - start) {	×
373	return [arr.slice(start)];	×
374	}
375	const ret: any[][] = [];	×
376	for (let i = start; i < arr.length; ++i) {	×
377	Utils.getAnyX(num - 1, arr, i + 1).forEach((a): void => {	×
378	a.push(arr[i]);	×
379	ret.push(a);	×
380	});
381	}
382	return ret;	×
383	}
384	}
385
386	export class LRU<V> {	1✔
387	data: { [key: string]: { value: V; usage: number } } = {};	95✔
388
389	constructor(public readonly size: number) {	95✔
390	}
391
392	set(key: string, value: V): void {
393	this.data[key] = {usage: Date.now(), value};	×
394	if (Object.keys(this.data).length > this.size) {	×
395	let oldestK = key;	×
396	let oldest = this.data[oldestK].usage;	×
397	for (const k in this.data) {	×
398	if (this.data[k].usage < oldest) {	×
399	oldestK = k;	×
400	oldest = this.data[oldestK].usage;	×
401	}
402	}
403	delete this.data[oldestK];	×
404	}
405	}
406
407	get(key: string): V {
408	if (!this.data[key]) {	×
409	return;	×
410	}
411	return this.data[key].value;	×
412	}
413	}

bpatrik / pigallery2 / 8286875510

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