8544502009

Committed 03 Apr 2024 07:34PM UTC coverage: 65.095% (+0.008%) from 65.087%

Build # 8544502009

Build Type

Pull #874

github

Committed by

web-flow

Commit Message

Merge f8021348d into 6c53aca7e

Pull Request Pull Request #874: Feature/timestamp fix

Run Details

1538 of 2686 branches covered (57.26%)

Branch coverage included in aggregate %.

5 of 5 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

4411 of 6453 relevant lines covered (68.36%)

13359.02 hits per line

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

60.93

/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 || timestamp.substring(9,timestamp.length).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 extract offset string from timestamp string, returns undefined if timestamp does not contain offset
  static timestampToOffsetString(timestamp: string) {
    try {
      const idx = timestamp.indexOf("+");
      if (idx > 0) {
        return timestamp.substring(idx, timestamp.length);
      }
      if (timestamp.indexOf("Z") > 0) {
        return '+00:00';
      }
      return undefined;
    } catch (err) {
      return undefined;
    }
  }

  //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;
  }

  public static xmpExifGpsCoordinateToDecimalDegrees(text: string): number {
    if (!text) {
      return undefined;
    }
    const parts = text.match(/^([0-9]+),([0-9.]+)([EWNS])$/);
    const degrees: number = parseInt(parts[1], 10);
    const minutes: number = parseFloat(parts[2]);
    const sign = (parts[3] === "N" || parts[3] === "E") ? 1 : -1;
    return (sign * (degrees + (minutes / 60.0)))
  }


  public static sortableFilename(filename: string): string {
    const lastDot = filename.lastIndexOf(".");

    // Avoid 0 as well as -1 to prevent empty names for extensionless dot-files
    if (lastDot > 0) {
      return filename.substring(0, lastDot);
    }

    // Fallback to the full name
    return filename;
  }
}

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,143!
27	return obj;	×
28	}
29
30	const keys = Object.keys(obj);	2,143✔
31	for (const key of keys) {	2,143✔
32	if (obj[key] !== null && typeof obj[key] === 'object') {	8,068✔
33	if (Utils.removeNullOrEmptyObj(obj[key])) {	1,959!
34	if (Object.keys(obj[key]).length === 0) {	1,959✔
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,143✔
43	}
44
45	static clone<T>(object: T): T {
46	return JSON.parse(JSON.stringify(object));	4,992✔
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 {	164✔
66	if (typeof filter !== 'object' \|\| filter == null) {	232✔
67	return object === filter;	23✔
68	}
69	if (!object) {	209✔
70	return false;	12✔
71	}
72
73	if (Array.isArray(object) && object.length !== filter.length) {	197!
74	return false;	×
75	}
76	const keys = Object.keys(filter);	197✔
77	for (const key of keys) {	197✔
78	if (skipProp.includes(key)) {	554!
79	continue;	×
80	}
81	if (typeof filter[key] === 'object') {	554✔
82	if (Utils.equalsFilter(object[key], filter[key], skipProp) === false) {	68✔
83	return false;	12✔
84	}
85	} else if (object[key] !== filter[key]) {	486✔
86	return false;	17✔
87	}
88	}
89
90	return true;	168✔
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) {	936✔
130	return undefined;	577✔
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);	359✔
134	if (formattedTimestamp.indexOf("Z") > 0) { //replace Z (and what comes after the Z) with offset	359✔
135	formattedTimestamp.substring(0, formattedTimestamp.indexOf("Z")) + (offset ? offset : '+00:00');	13!
136	} else if (formattedTimestamp.indexOf("+") > 0 \|\| timestamp.substring(9,timestamp.length).indexOf("-") > 0) { //don't do anything	346✔
137	} else { //add offset
138	formattedTimestamp = formattedTimestamp + (offset ? offset : '+00:00');	276✔
139	}
140	//parse into MS and return
141	return Date.parse(formattedTimestamp);	359✔
142	}
143
144	//function to extract offset string from timestamp string, returns undefined if timestamp does not contain offset
145	static timestampToOffsetString(timestamp: string) {
146	try {	541✔
147	const idx = timestamp.indexOf("+");	541✔
148	if (idx > 0) {	129✔
149	return timestamp.substring(idx, timestamp.length);	17✔
150	}
151	if (timestamp.indexOf("Z") > 0) {	112!
UNCOV 152	return '+00:00';	×
153	}
154	return undefined;	112✔
155	} catch (err) {
156	return undefined;	412✔
157	}
158	}
159
160	//function to calculate offset from exif.exif.gpsTimeStamp or exif.gps.GPSDateStamp + exif.gps.GPSTimestamp
161	static getTimeOffsetByGPSStamp(timestamp: string, gpsTimeStamp: string, gps: any) {
162	let UTCTimestamp = gpsTimeStamp;	116✔
163	if (!UTCTimestamp &&	116✔
164	gps &&
165	gps.GPSDateStamp &&
166	gps.GPSTimeStamp) { //else use exif.gps.GPS*Stamp if available
167	//GPS timestamp is always UTC (+00:00)
168	UTCTimestamp = gps.GPSDateStamp.replaceAll(':', '-') + gps.GPSTimeStamp.join(':');	13✔
169	}
170	if (UTCTimestamp && timestamp) {	116✔
171	//offset in minutes is the difference between gps timestamp and given timestamp
172	//to calculate this correctly, we have to work with the same offset
173	const offsetMinutes = (Utils.timestampToMS(timestamp, '+00:00')- Utils.timestampToMS(UTCTimestamp, '+00:00')) / 1000 / 60;	27✔
174	return Utils.getOffsetString(offsetMinutes);	27✔
175	} else {
176	return undefined;	89✔
177	}
178	}
179
180	static getOffsetString(offsetMinutes: number) {
181	if (-720 <= offsetMinutes && offsetMinutes <= 840) {	3,738✔
182	//valid offset is within -12 and +14 hrs (https://en.wikipedia.org/wiki/List_of_UTC_offsets)
183	return (offsetMinutes < 0 ? "-" : "+") + //leading +/-	3,713✔
184	("0" + Math.trunc(Math.abs(offsetMinutes) / 60)).slice(-2) + ":" + //zeropadded hours and ':'
185	("0" + Math.abs(offsetMinutes) % 60).slice(-2); //zeropadded minutes
186	} else {
187	return undefined;	25✔
188	}
189	}
190
191	static getOffsetMinutes(offsetString: string) { //Convert offset string (+HH:MM or -HH:MM) into a minute value
192	const regex = /^([+-](0[0-9]\|1[0-4]):[0-5][0-9])$/; //checks if offset is between -14:00 and +14:00.	3,412✔
193	//-12:00 is the lowest valid UTC-offset, but we allow down to -14 for efficiency
194	if (regex.test(offsetString)) {	3,412✔
195	const hhmm = offsetString.split(":");	3,262✔
196	const hours = parseInt(hhmm[0]);	3,262✔
197	return hours < 0 ? ((hours60) - parseInt(hhmm[1])) : ((hours60) + parseInt(hhmm[1]));	3,262✔
198	} else {
199	return undefined;	150✔
200	}
201	}
202
203	static isLeapYear(year: number) {
204	return (0 == year % 4) && (0 != year % 100) \|\| (0 == year % 400)	40!
205	}
206
207	static isDateFromLeapYear(date: Date) {
208	return Utils.isLeapYear(date.getFullYear());	24✔
209	}
210
211	// Get Day of Year
212	static getDayOfYear(date: Date) {
213	//Day-number at the start of Jan to Dec. A month baseline
214	const dayCount = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];	16✔
215	const mn = date.getMonth();	16✔
216	let dayOfYear = dayCount[mn] + date.getDate(); //add the date to the month baseline	16✔
217	if (mn > 1 && Utils.isLeapYear((date.getFullYear()))) {	16!
218	dayOfYear++; //Add an extra day for march to december (mn>1) on leap years	16✔
219	}
220	return dayOfYear;	16✔
221	}
222
223	static renderDataSize(size: number): string {
224	const postFixes = ['B', 'KB', 'MB', 'GB', 'TB'];	×
225	let index = 0;	×
226	while (size > 1000 && index < postFixes.length - 1) {	×
227	size /= 1000;	×
228	index++;	×
229	}
230	return size.toFixed(2) + postFixes[index];	×
231	}
232
233	static getUnique(arr: any[]) {
234	return arr.filter((value, index, arr) => arr.indexOf(value) === index);	×
235	}
236
237	static createRange(from: number, to: number): Array<number> {
238	const arr = new Array(to - from + 1);	×
239	let c = to - from + 1;	×
240	while (c--) {	×
241	arr[c] = to--;	×
242	}
243	return arr;	×
244	}
245
246	public static canonizePath(path: string): string {
247	return path	75✔
248	.replace(new RegExp('\\\\', 'g'), '/')
249	.replace(new RegExp('/+', 'g'), '/');
250	}
251
252	static concatUrls(...args: string[]): string {
253	let url = '';	22✔
254	for (const item of args) {	22✔
255	if (item === '' \|\| typeof item === 'undefined') {	46!
256	continue;	×
257	}
258
259	const part = item.replace(new RegExp('\\\\', 'g'), '/');	46✔
260	if (part === '/' \|\| part === './') {	46✔
261	continue;	5✔
262	}
263
264	url += part + '/';	41✔
265	}
266	url = url.replace(/(https?:\/\/)\|(\/){2,}/g, '$1$2');	22✔
267
268	if (url.trim() === '') {	22✔
269	url = './';	1✔
270	}
271
272	return url.substring(0, url.length - 1);	22✔
273	}
274
275	public static updateKeys(targetObject: any, sourceObject: any): void {
276	Object.keys(sourceObject).forEach((key): void => {	×
277	if (typeof targetObject[key] === 'undefined') {	×
278	return;	×
279	}
280	if (typeof targetObject[key] === 'object') {	×
281	Utils.updateKeys(targetObject[key], sourceObject[key]);	×
282	} else {
283	targetObject[key] = sourceObject[key];	×
284	}
285	});
286	}
287
288	public static setKeys(targetObject: any, sourceObject: any): void {
289	Object.keys(sourceObject).forEach((key): void => {	×
290	if (typeof targetObject[key] === 'object') {	×
291	Utils.setKeys(targetObject[key], sourceObject[key]);	×
292	} else {
293	targetObject[key] = sourceObject[key];	×
294	}
295	});
296	}
297
298	public static setKeysForced(targetObject: any, sourceObject: any): void {
299	Object.keys(sourceObject).forEach((key): void => {	×
300	if (typeof sourceObject[key] === 'object') {	×
301	if (typeof targetObject[key] === 'undefined') {	×
302	targetObject[key] = {};	×
303	}
304	Utils.setKeysForced(targetObject[key], sourceObject[key]);	×
305	} else {
306	targetObject[key] = sourceObject[key];	×
307	}
308	});
309	}
310
311	public static isValidEnumInt(EnumType: any, value: number) {
312	return typeof EnumType[value] === 'string';	6✔
313	}
314
315	public static enumToArray(EnumType: any): { key: number; value: string }[] {
316	const arr: Array<{ key: number; value: string }> = [];	1✔
317	for (const enumMember in EnumType) {	1✔
318	// eslint-disable-next-line no-prototype-builtins
319	if (!EnumType.hasOwnProperty(enumMember)) {	12!
320	continue;	×
321	}
322	const key = parseInt(enumMember, 10);	12✔
323	if (key >= 0) {	12✔
324	arr.push({key, value: EnumType[enumMember]});	6✔
325	}
326	}
327	return arr;	1✔
328	}
329
330	public static findClosest(num: number, arr: number[]): number {
331	let curr = arr[0];	4✔
332	let diff = Math.abs(num - curr);	4✔
333
334	arr.forEach((value): void => {	4✔
335	const newDiff = Math.abs(num - value);	10✔
336
337	if (newDiff < diff) {	10!
338	diff = newDiff;	×
339	curr = value;	×
340	}
341	});
342
343	return curr;	4✔
344	}
345
346	public static findClosestinSorted(num: number, arr: number[]): number {
347	let curr = arr[0];	6✔
348	let diff = Math.abs(num - curr);	6✔
349	for (const item of arr) {	6✔
350	const newDiff = Math.abs(num - item);	19✔
351	if (newDiff > diff) {	19✔
352	break;	5✔
353	}
354	diff = newDiff;	14✔
355	curr = item;	14✔
356	}
357
358	return curr;	6✔
359	}
360
361	public static isUInt32(value: number, max = 4294967295): boolean {	212✔
362	value = parseInt('' + value, 10);	212✔
363	return !isNaN(value) && value >= 0 && value <= max;	212✔
364	}
365
366	public static isInt32(value: number): boolean {
367	value = parseFloat('' + value);	205✔
368	return !isNaN(value) && value >= -2147483648 && value <= 2147483647;	205✔
369	}
370
371	public static isFloat32(value: number): boolean {
372	const E = Math.pow(10, 38);	846✔
373	const nE = Math.pow(10, -38);	846✔
374	return (	846✔
375	!isNaN(value) &&	2,470✔
376	((value >= -3.402823466 * E && value <= -1.175494351 * nE) \|\|
377	(value <= 3.402823466 * E && value >= 1.175494351 * nE))
378	);
379	}
380
381	public static getAnyX(num: number, arr: any[], start = 0): any[][] {	×
382	if (num <= 0 \|\| num > arr.length \|\| start >= arr.length) {	×
383	return [];	×
384	}
385	if (num <= 1) {	×
386	return arr.slice(start).map((e): any[] => [e]);	×
387	}
388	if (num === arr.length - start) {	×
389	return [arr.slice(start)];	×
390	}
391	const ret: any[][] = [];	×
392	for (let i = start; i < arr.length; ++i) {	×
393	Utils.getAnyX(num - 1, arr, i + 1).forEach((a): void => {	×
394	a.push(arr[i]);	×
395	ret.push(a);	×
396	});
397	}
398	return ret;	×
399	}
400
401	public static xmpExifGpsCoordinateToDecimalDegrees(text: string): number {
402	if (!text) {	78✔
403	return undefined;	22✔
404	}
405	const parts = text.match(/^([0-9]+),([0-9.]+)([EWNS])$/);	56✔
406	const degrees: number = parseInt(parts[1], 10);	56✔
407	const minutes: number = parseFloat(parts[2]);	56✔
408	const sign = (parts[3] === "N" \|\| parts[3] === "E") ? 1 : -1;	56!
409	return (sign * (degrees + (minutes / 60.0)))	56✔
410	}
411
412
413	public static sortableFilename(filename: string): string {
414	const lastDot = filename.lastIndexOf(".");	4✔
415
416	// Avoid 0 as well as -1 to prevent empty names for extensionless dot-files
417	if (lastDot > 0) {	4✔
418	return filename.substring(0, lastDot);	2✔
419	}
420
421	// Fallback to the full name
422	return filename;	2✔
423	}
424	}
425
426	export class LRU<V> {	1✔
427	data: { [key: string]: { value: V; usage: number } } = {};	95✔
428
429	constructor(public readonly size: number) {	95✔
430	}
431
432	set(key: string, value: V): void {
433	this.data[key] = {usage: Date.now(), value};	×
434	if (Object.keys(this.data).length > this.size) {	×
435	let oldestK = key;	×
436	let oldest = this.data[oldestK].usage;	×
437	for (const k in this.data) {	×
438	if (this.data[k].usage < oldest) {	×
439	oldestK = k;	×
440	oldest = this.data[oldestK].usage;	×
441	}
442	}
443	delete this.data[oldestK];	×
444	}
445	}
446
447	get(key: string): V {
448	if (!this.data[key]) {	×
449	return;	×
450	}
451	return this.data[key].value;	×
452	}
453	}

bpatrik / pigallery2 / 8544502009

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