8499927153

Committed 31 Mar 2024 05:50PM UTC coverage: 65.293% (+0.1%) from 65.162%

Build # 8499927153

Build Type

Pull #870

github

Committed by

web-flow

Commit Message

Merge 893df7db7 into 086bc47a0

Pull Request Pull Request #870: Feature/caption and title (#14)

Run Details

1551 of 2685 branches covered (57.77%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 2 files covered. (100.0%)

38 existing lines in 1 file now uncovered.

4422 of 6463 relevant lines covered (68.42%)

13339.51 hits per line

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

62.63

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

  //Adding months to a date differently from standard JS
  //this function makes sure that if date is the 31st and you add a month, you will get the last day of the next month
  //so adding or subtracting a month from 31st of march will give 30th of april or 28th of february respectively (29th on leap years).
  static addMonthToDate(date: Date, numMonths: number) {
    const result = new Date(date)
    const expectedMonth = ((date.getMonth() + numMonths) % 12 + 12) % 12; //inner %12 + 12 makes correct handling of negative months
    result.setMonth(result.getMonth() + numMonths);
    if (result.getMonth() !== expectedMonth) {
      result.setDate(0);
    }
    return result;
  }

  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,159!
27	return obj;	×
28	}
29
30	const keys = Object.keys(obj);	2,159✔
31	for (const key of keys) {	2,159✔
32	if (obj[key] !== null && typeof obj[key] === 'object') {	8,120✔
33	if (Utils.removeNullOrEmptyObj(obj[key])) {	1,973!
34	if (Object.keys(obj[key]).length === 0) {	1,973✔
35	delete obj[key];	251✔
36	}
37	}
38	} else if (obj[key] === null) {	6,147✔
39	delete obj[key];	926✔
40	}
41	}
42	return obj;	2,159✔
43	}
44
45	static clone<T>(object: T): T {
46	return JSON.parse(JSON.stringify(object));	5,017✔
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 {	168✔
66	if (typeof filter !== 'object' \|\| filter == null) {	236✔
67	return object === filter;	23✔
68	}
69	if (!object) {	213✔
70	return false;	12✔
71	}
72
73	if (Array.isArray(object) && object.length !== filter.length) {	201!
74	return false;	×
75	}
76	const keys = Object.keys(filter);	201✔
77	for (const key of keys) {	201✔
78	if (skipProp.includes(key)) {	562!
79	continue;	×
80	}
81	if (typeof filter[key] === 'object') {	562✔
82	if (Utils.equalsFilter(object[key], filter[key], skipProp) === false) {	68✔
83	return false;	12✔
84	}
85	} else if (object[key] !== filter[key]) {	494✔
86	return false;	17✔
87	}
88	}
89
90	return true;	172✔
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) {	978✔
130	return undefined;	583✔
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);	395✔
134	if (formattedTimestamp.indexOf("Z") > 0) { //replace Z (and what comes after the Z) with offset	395✔
135	formattedTimestamp = formattedTimestamp.substring(0, formattedTimestamp.indexOf("Z")) + (offset ? offset : '+00:00');	15✔
136	} else if (formattedTimestamp.indexOf("+") > 0) { //don't do anything	380✔
137	} else { //add offset
138	formattedTimestamp = formattedTimestamp + (offset ? offset : '+00:00');	309✔
139	}
140	//parse into MS and return
141	return Date.parse(formattedTimestamp);	395✔
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 {	578✔
147	const idx = timestamp.indexOf("+");	578✔
148	if (idx > 0) {	162✔
149	return timestamp.substring(idx, timestamp.length);	18✔
150	}
151	if (timestamp.indexOf("Z") > 0) {	144✔
152	return '+00:00';	1✔
153	}
154	return undefined;	143✔
155	} catch (err) {
156	return undefined;	416✔
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;	132✔
163	if (!UTCTimestamp &&	132✔
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) {	132✔
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;	28✔
174	return Utils.getOffsetString(offsetMinutes);	28✔
175	} else {
176	return undefined;	104✔
177	}
178	}
179
180	static getOffsetString(offsetMinutes: number) {
181	if (-720 <= offsetMinutes && offsetMinutes <= 840) {	3,739✔
182	//valid offset is within -12 and +14 hrs (https://en.wikipedia.org/wiki/List_of_UTC_offsets)
183	return (offsetMinutes < 0 ? "-" : "+") + //leading +/-	3,714✔
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,420✔
193	//-12:00 is the lowest valid UTC-offset, but we allow down to -14 for efficiency
194	if (regex.test(offsetString)) {	3,420✔
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;	158✔
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	//Adding months to a date differently from standard JS
224	//this function makes sure that if date is the 31st and you add a month, you will get the last day of the next month
225	//so adding or subtracting a month from 31st of march will give 30th of april or 28th of february respectively (29th on leap years).
226	static addMonthToDate(date: Date, numMonths: number) {
227	const result = new Date(date)	12✔
228	const expectedMonth = ((date.getMonth() + numMonths) % 12 + 12) % 12; //inner %12 + 12 makes correct handling of negative months	12✔
229	result.setMonth(result.getMonth() + numMonths);	12✔
230	if (result.getMonth() !== expectedMonth) {	12✔
231	result.setDate(0);	4✔
232	}
233	return result;	12✔
234	}
235
236	static renderDataSize(size: number): string {
UNCOV 237	const postFixes = ['B', 'KB', 'MB', 'GB', 'TB'];	×
238	let index = 0;	×
239	while (size > 1000 && index < postFixes.length - 1) {	×
240	size /= 1000;	×
241	index++;	×
242	}
243	return size.toFixed(2) + postFixes[index];	×
244	}
245
246	static getUnique(arr: any[]) {
UNCOV 247	return arr.filter((value, index, arr) => arr.indexOf(value) === index);	×
248	}
249
250	static createRange(from: number, to: number): Array<number> {
UNCOV 251	const arr = new Array(to - from + 1);	×
UNCOV 252	let c = to - from + 1;	×
UNCOV 253	while (c--) {	×
UNCOV 254	arr[c] = to--;	×
255	}
256	return arr;	×
257	}
258
259	public static canonizePath(path: string): string {
260	return path	75✔
261	.replace(new RegExp('\\\\', 'g'), '/')
262	.replace(new RegExp('/+', 'g'), '/');
263	}
264
265	static concatUrls(...args: string[]): string {
266	let url = '';	22✔
267	for (const item of args) {	22✔
268	if (item === '' \|\| typeof item === 'undefined') {	46!
UNCOV 269	continue;	×
270	}
271
272	const part = item.replace(new RegExp('\\\\', 'g'), '/');	46✔
273	if (part === '/' \|\| part === './') {	46✔
274	continue;	5✔
275	}
276
277	url += part + '/';	41✔
278	}
279	url = url.replace(/(https?:\/\/)\|(\/){2,}/g, '$1$2');	22✔
280
281	if (url.trim() === '') {	22✔
282	url = './';	1✔
283	}
284
285	return url.substring(0, url.length - 1);	22✔
286	}
287
288	public static updateKeys(targetObject: any, sourceObject: any): void {
289	Object.keys(sourceObject).forEach((key): void => {	×
290	if (typeof targetObject[key] === 'undefined') {	×
291	return;	×
292	}
293	if (typeof targetObject[key] === 'object') {	×
UNCOV 294	Utils.updateKeys(targetObject[key], sourceObject[key]);	×
295	} else {
UNCOV 296	targetObject[key] = sourceObject[key];	×
297	}
298	});
299	}
300
301	public static setKeys(targetObject: any, sourceObject: any): void {
302	Object.keys(sourceObject).forEach((key): void => {	×
UNCOV 303	if (typeof targetObject[key] === 'object') {	×
304	Utils.setKeys(targetObject[key], sourceObject[key]);	×
305	} else {
306	targetObject[key] = sourceObject[key];	×
307	}
308	});
309	}
310
311	public static setKeysForced(targetObject: any, sourceObject: any): void {
UNCOV 312	Object.keys(sourceObject).forEach((key): void => {	×
UNCOV 313	if (typeof sourceObject[key] === 'object') {	×
UNCOV 314	if (typeof targetObject[key] === 'undefined') {	×
UNCOV 315	targetObject[key] = {};	×
316	}
UNCOV 317	Utils.setKeysForced(targetObject[key], sourceObject[key]);	×
318	} else {
UNCOV 319	targetObject[key] = sourceObject[key];	×
320	}
321	});
322	}
323
324	public static isValidEnumInt(EnumType: any, value: number) {
325	return typeof EnumType[value] === 'string';	6✔
326	}
327
328	public static enumToArray(EnumType: any): { key: number; value: string }[] {
329	const arr: Array<{ key: number; value: string }> = [];	1✔
330	for (const enumMember in EnumType) {	1✔
331	// eslint-disable-next-line no-prototype-builtins
332	if (!EnumType.hasOwnProperty(enumMember)) {	12!
UNCOV 333	continue;	×
334	}
335	const key = parseInt(enumMember, 10);	12✔
336	if (key >= 0) {	12✔
337	arr.push({key, value: EnumType[enumMember]});	6✔
338	}
339	}
340	return arr;	1✔
341	}
342
343	public static findClosest(num: number, arr: number[]): number {
344	let curr = arr[0];	4✔
345	let diff = Math.abs(num - curr);	4✔
346
347	arr.forEach((value): void => {	4✔
348	const newDiff = Math.abs(num - value);	10✔
349
350	if (newDiff < diff) {	10!
UNCOV 351	diff = newDiff;	×
UNCOV 352	curr = value;	×
353	}
354	});
355
356	return curr;	4✔
357	}
358
359	public static findClosestinSorted(num: number, arr: number[]): number {
360	let curr = arr[0];	6✔
361	let diff = Math.abs(num - curr);	6✔
362	for (const item of arr) {	6✔
363	const newDiff = Math.abs(num - item);	19✔
364	if (newDiff > diff) {	19✔
365	break;	5✔
366	}
367	diff = newDiff;	14✔
368	curr = item;	14✔
369	}
370
371	return curr;	6✔
372	}
373
374	public static isUInt32(value: number, max = 4294967295): boolean {	228✔
375	value = parseInt('' + value, 10);	228✔
376	return !isNaN(value) && value >= 0 && value <= max;	228✔
377	}
378
379	public static isInt32(value: number): boolean {
380	value = parseFloat('' + value);	205✔
381	return !isNaN(value) && value >= -2147483648 && value <= 2147483647;	205✔
382	}
383
384	public static isFloat32(value: number): boolean {
385	const E = Math.pow(10, 38);	902✔
386	const nE = Math.pow(10, -38);	902✔
387	return (	902✔
388	!isNaN(value) &&	2,582✔
389	((value >= -3.402823466 * E && value <= -1.175494351 * nE) \|\|
390	(value <= 3.402823466 * E && value >= 1.175494351 * nE))
391	);
392	}
393
394	public static getAnyX(num: number, arr: any[], start = 0): any[][] {	×
395	if (num <= 0 \|\| num > arr.length \|\| start >= arr.length) {	×
UNCOV 396	return [];	×
397	}
398	if (num <= 1) {	×
UNCOV 399	return arr.slice(start).map((e): any[] => [e]);	×
400	}
UNCOV 401	if (num === arr.length - start) {	×
UNCOV 402	return [arr.slice(start)];	×
403	}
UNCOV 404	const ret: any[][] = [];	×
UNCOV 405	for (let i = start; i < arr.length; ++i) {	×
UNCOV 406	Utils.getAnyX(num - 1, arr, i + 1).forEach((a): void => {	×
UNCOV 407	a.push(arr[i]);	×
UNCOV 408	ret.push(a);	×
409	});
410	}
UNCOV 411	return ret;	×
412	}
413
414	public static xmpExifGpsCoordinateToDecimalDegrees(text: string): number {
415	if (!text) {	80✔
416	return undefined;	22✔
417	}
418	const parts = text.match(/^([0-9]+),([0-9.]+)([EWNS])$/);	58✔
419	const degrees: number = parseInt(parts[1], 10);	58✔
420	const minutes: number = parseFloat(parts[2]);	58✔
421	const sign = (parts[3] === "N" \|\| parts[3] === "E") ? 1 : -1;	58✔
422	return (sign * (degrees + (minutes / 60.0)))	58✔
423	}
424
425
426	public static sortableFilename(filename: string): string {
427	const lastDot = filename.lastIndexOf(".");	4✔
428
429	// Avoid 0 as well as -1 to prevent empty names for extensionless dot-files
430	if (lastDot > 0) {	4✔
431	return filename.substring(0, lastDot);	2✔
432	}
433
434	// Fallback to the full name
435	return filename;	2✔
436	}
437	}
438
439	export class LRU<V> {	1✔
440	data: { [key: string]: { value: V; usage: number } } = {};	95✔
441
442	constructor(public readonly size: number) {	95✔
443	}
444
445	set(key: string, value: V): void {
UNCOV 446	this.data[key] = {usage: Date.now(), value};	×
UNCOV 447	if (Object.keys(this.data).length > this.size) {	×
448	let oldestK = key;	×
449	let oldest = this.data[oldestK].usage;	×
UNCOV 450	for (const k in this.data) {	×
451	if (this.data[k].usage < oldest) {	×
UNCOV 452	oldestK = k;	×
UNCOV 453	oldest = this.data[oldestK].usage;	×
454	}
455	}
UNCOV 456	delete this.data[oldestK];	×
457	}
458	}
459
460	get(key: string): V {
UNCOV 461	if (!this.data[key]) {	×
UNCOV 462	return;	×
463	}
UNCOV 464	return this.data[key].value;	×
465	}
466	}

bpatrik / pigallery2 / 8499927153

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