X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Futils%2FUtils.ts;h=ae27035ff079c028f30bee9884d5b2de5521c18a;hb=1e2ec4a6612809e178b5237bf6302562ba3c0512;hp=86b0daa2d57a15a8f4f9893e28e49899b34b6eb1;hpb=98fc1389a2464ce8738047f8990731ae31938ee5;p=e-mobility-charging-stations-simulator.git diff --git a/src/utils/Utils.ts b/src/utils/Utils.ts index 86b0daa2..ae27035f 100644 --- a/src/utils/Utils.ts +++ b/src/utils/Utils.ts @@ -1,317 +1,428 @@ -import crypto from 'crypto'; +import { getRandomValues, randomBytes, randomInt, randomUUID } from 'node:crypto' +import { env, nextTick } from 'node:process' + +import { + formatDuration, + hoursToMinutes, + hoursToSeconds, + isDate, + millisecondsToHours, + millisecondsToMinutes, + millisecondsToSeconds, + minutesToSeconds, + secondsToMilliseconds +} from 'date-fns' + +import { Constants } from './Constants.js' +import { + type EmptyObject, + type TimestampedData, + WebSocketCloseEventStatusString +} from '../types/index.js' + +export const logPrefix = (prefixString = ''): string => { + return `${new Date().toLocaleString()}${prefixString}` +} -import clone from 'just-clone'; +export const generateUUID = (): string => { + return randomUUID() +} -import { WebSocketCloseEventStatusString } from '../types/WebSocket'; +export const validateUUID = (uuid: string): boolean => { + return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(uuid) +} -export default class Utils { - private constructor() { - // This is intentional - } +export const sleep = async (milliSeconds: number): Promise => { + return await new Promise(resolve => + setTimeout(resolve as () => void, milliSeconds) + ) +} - public static logPrefix(prefixString = ''): string { - return new Date().toLocaleString() + prefixString; +export const formatDurationMilliSeconds = (duration: number): string => { + duration = convertToInt(duration) + if (duration < 0) { + throw new RangeError('Duration cannot be negative') } - - public static generateUUID(): string { - return crypto.randomUUID(); + const days = Math.floor(duration / (24 * 3600 * 1000)) + const hours = Math.floor(millisecondsToHours(duration) - days * 24) + const minutes = Math.floor( + millisecondsToMinutes(duration) - days * 24 * 60 - hoursToMinutes(hours) + ) + const seconds = Math.floor( + millisecondsToSeconds(duration) - + days * 24 * 3600 - + hoursToSeconds(hours) - + minutesToSeconds(minutes) + ) + if (days === 0 && hours === 0 && minutes === 0 && seconds === 0) { + return formatDuration({ seconds }, { zero: true }) } + return formatDuration({ + days, + hours, + minutes, + seconds + }) +} - public static validateUUID(uuid: string): boolean { - return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test( - uuid - ); - } +export const formatDurationSeconds = (duration: number): string => { + return formatDurationMilliSeconds(secondsToMilliseconds(duration)) +} - public static async sleep(milliSeconds: number): Promise { - return new Promise((resolve) => setTimeout(resolve as () => void, milliSeconds)); +// More efficient time validation function than the one provided by date-fns +export const isValidDate = (date: Date | number | undefined): date is Date | number => { + if (typeof date === 'number') { + return !isNaN(date) + } else if (isDate(date)) { + return !isNaN(date.getTime()) } + return false +} - public static formatDurationMilliSeconds(duration: number): string { - duration = Utils.convertToInt(duration); - const hours = Math.floor(duration / (3600 * 1000)); - const minutes = Math.floor((duration / 1000 - hours * 3600) / 60); - const seconds = duration / 1000 - hours * 3600 - minutes * 60; - let hoursStr = hours.toString(); - let minutesStr = minutes.toString(); - let secondsStr = seconds.toString(); - - if (hours < 10) { - hoursStr = '0' + hours.toString(); - } - if (minutes < 10) { - minutesStr = '0' + minutes.toString(); - } - if (seconds < 10) { - secondsStr = '0' + seconds.toString(); - } - return hoursStr + ':' + minutesStr + ':' + secondsStr.substring(0, 6); +export const convertToDate = ( + value: Date | string | number | undefined | null +): Date | undefined => { + if (value == null) { + return undefined } - - public static formatDurationSeconds(duration: number): string { - return Utils.formatDurationMilliSeconds(duration * 1000); + if (isDate(value)) { + return value } - - public static convertToDate( - value: Date | string | number | null | undefined - ): Date | null | undefined { - if (Utils.isNullOrUndefined(value)) { - return value as null | undefined; + if (isString(value) || typeof value === 'number') { + const valueToDate = new Date(value) + if (isNaN(valueToDate.getTime())) { + throw new Error(`Cannot convert to date: '${value}'`) } - if (value instanceof Date) { - return value; - } - if (Utils.isString(value) || typeof value === 'number') { - return new Date(value); - } - return null; + return valueToDate } +} - public static convertToInt(value: unknown): number { - if (!value) { - return 0; - } - let changedValue: number = value as number; - if (Number.isSafeInteger(value)) { - return value as number; - } - if (typeof value === 'number') { - return Math.trunc(value); - } - if (Utils.isString(value)) { - changedValue = parseInt(value as string); - } - if (isNaN(changedValue)) { - throw new Error(`Cannot convert to integer: ${value.toString()}`); - } - return changedValue; +export const convertToInt = (value: unknown): number => { + if (value == null) { + return 0 } - - public static convertToFloat(value: unknown): number { - if (!value) { - return 0; - } - let changedValue: number = value as number; - if (Utils.isString(value)) { - changedValue = parseFloat(value as string); - } - if (isNaN(changedValue)) { - throw new Error(`Cannot convert to float: ${value.toString()}`); - } - return changedValue; - } - - public static convertToBoolean(value: unknown): boolean { - let result = false; - if (value) { - // Check the type - if (typeof value === 'boolean') { - return value; - } else if ( - Utils.isString(value) && - ((value as string).toLowerCase() === 'true' || value === '1') - ) { - result = true; - } else if (typeof value === 'number' && value === 1) { - result = true; - } - } - return result; + let changedValue: number = value as number + if (Number.isSafeInteger(value)) { + return value as number } - - public static getRandomFloat(max = Number.MAX_VALUE, min = 0, negative = false): number { - if (max < min || max < 0 || min < 0) { - throw new RangeError('Invalid interval'); - } - const randomPositiveFloat = crypto.randomBytes(4).readUInt32LE() / 0xffffffff; - const sign = negative && randomPositiveFloat < 0.5 ? -1 : 1; - return sign * (randomPositiveFloat * (max - min) + min); + if (typeof value === 'number') { + return Math.trunc(value) } - - public static getRandomInteger(max = Number.MAX_SAFE_INTEGER, min = 0): number { - if (max < min || max < 0 || min < 0) { - throw new RangeError('Invalid interval'); - } - max = Math.floor(max); - if (!Utils.isNullOrUndefined(min) && min !== 0) { - min = Math.ceil(min); - return Math.floor(Utils.secureRandom() * (max - min + 1)) + min; - } - return Math.floor(Utils.secureRandom() * (max + 1)); + if (isString(value)) { + changedValue = parseInt(value) } - - public static roundTo(numberValue: number, scale: number): number { - const roundPower = Math.pow(10, scale); - return Math.round(numberValue * roundPower) / roundPower; + if (isNaN(changedValue)) { + throw new Error(`Cannot convert to integer: '${String(value)}'`) } + return changedValue +} - public static truncTo(numberValue: number, scale: number): number { - const truncPower = Math.pow(10, scale); - return Math.trunc(numberValue * truncPower) / truncPower; +export const convertToFloat = (value: unknown): number => { + if (value == null) { + return 0 } - - public static getRandomFloatRounded(max = Number.MAX_VALUE, min = 0, scale = 2): number { - if (min) { - return Utils.roundTo(Utils.getRandomFloat(max, min), scale); - } - return Utils.roundTo(Utils.getRandomFloat(max), scale); + let changedValue: number = value as number + if (isString(value)) { + changedValue = parseFloat(value) + } + if (isNaN(changedValue)) { + throw new Error(`Cannot convert to float: '${String(value)}'`) } + return changedValue +} - public static getRandomFloatFluctuatedRounded( - staticValue: number, - fluctuationPercent: number, - scale = 2 - ): number { - if (fluctuationPercent === 0) { - return Utils.roundTo(staticValue, scale); +export const convertToBoolean = (value: unknown): boolean => { + let result = false + if (value != null) { + // Check the type + if (typeof value === 'boolean') { + return value + } else if (isString(value) && (value.toLowerCase() === 'true' || value === '1')) { + result = true + } else if (typeof value === 'number' && value === 1) { + result = true } - const fluctuationRatio = fluctuationPercent / 100; - return Utils.getRandomFloatRounded( - staticValue * (1 + fluctuationRatio), - staticValue * (1 - fluctuationRatio), - scale - ); } + return result +} - public static isObject(item: unknown): boolean { - return ( - Utils.isNullOrUndefined(item) === false && - typeof item === 'object' && - Array.isArray(item) === false - ); +export const getRandomFloat = (max = Number.MAX_VALUE, min = 0): number => { + if (max < min) { + throw new RangeError('Invalid interval') } - - public static cloneObject(object: T): T { - return clone(object); + if (max - min === Infinity) { + throw new RangeError('Invalid interval') } + return (randomBytes(4).readUInt32LE() / 0xffffffff) * (max - min) + min +} - public static isIterable(obj: T): boolean { - return obj ? typeof obj[Symbol.iterator] === 'function' : false; +export const getRandomInteger = (max = Constants.MAX_RANDOM_INTEGER, min = 0): number => { + max = Math.floor(max) + if (min !== 0) { + min = Math.ceil(min) + return Math.floor(randomInt(min, max + 1)) } + return Math.floor(randomInt(max + 1)) +} - public static isString(value: unknown): boolean { - return typeof value === 'string'; - } +/** + * Rounds the given number to the given scale. + * The rounding is done using the "round half away from zero" method. + * + * @param numberValue - The number to round. + * @param scale - The scale to round to. + * @returns The rounded number. + */ +export const roundTo = (numberValue: number, scale: number): number => { + const roundPower = Math.pow(10, scale) + return Math.round(numberValue * roundPower * (1 + Number.EPSILON)) / roundPower +} - public static isEmptyString(value: unknown): boolean { - return Utils.isString(value) && (value as string).trim().length === 0; +export const getRandomFloatRounded = (max = Number.MAX_VALUE, min = 0, scale = 2): number => { + if (min !== 0) { + return roundTo(getRandomFloat(max, min), scale) } + return roundTo(getRandomFloat(max), scale) +} - public static isUndefined(value: unknown): boolean { - return typeof value === 'undefined'; +export const getRandomFloatFluctuatedRounded = ( + staticValue: number, + fluctuationPercent: number, + scale = 2 +): number => { + if (fluctuationPercent < 0 || fluctuationPercent > 100) { + throw new RangeError( + `Fluctuation percent must be between 0 and 100. Actual value: ${fluctuationPercent}` + ) } - - public static isNullOrUndefined(value: unknown): boolean { - // eslint-disable-next-line eqeqeq, no-eq-null - return value == null ? true : false; + if (fluctuationPercent === 0) { + return roundTo(staticValue, scale) } + const fluctuationRatio = fluctuationPercent / 100 + return getRandomFloatRounded( + staticValue * (1 + fluctuationRatio), + staticValue * (1 - fluctuationRatio), + scale + ) +} - public static isEmptyArray(object: unknown | unknown[]): boolean { - if (!Array.isArray(object)) { - return true; - } - if (object.length > 0) { - return false; - } - return true; - } +export const extractTimeSeriesValues = (timeSeries: TimestampedData[]): number[] => { + return timeSeries.map(timeSeriesItem => timeSeriesItem.value) +} - public static isEmptyObject(obj: object): boolean { - if (obj?.constructor !== Object) { - return false; - } - // Iterates over the keys of an object, if - // any exist, return false. - for (const _ in obj) { - return false; +type CloneableData = + | number + | string + | boolean + | null + | undefined + | Date + | CloneableData[] + | { [key: string]: CloneableData } + +type FormatKey = (key: string) => string + +const deepClone = ( + value: I, + formatKey?: FormatKey, + refs: Map = new Map() +): O => { + const ref = refs.get(value) + if (ref !== undefined) { + return ref + } + if (Array.isArray(value)) { + const clone: CloneableData[] = [] + refs.set(value, clone as O) + for (let i = 0; i < value.length; i++) { + clone[i] = deepClone(value[i], formatKey, refs) } - return true; + return clone as O + } + if (value instanceof Date) { + return new Date(value.getTime()) as O } + if (typeof value !== 'object' || value === null) { + return value as unknown as O + } + const clone: Record = {} + refs.set(value, clone as O) + for (const key of Object.keys(value)) { + clone[typeof formatKey === 'function' ? formatKey(key) : key] = deepClone( + value[key], + formatKey, + refs + ) + } + return clone as O +} - public static insertAt = (str: string, subStr: string, pos: number): string => - `${str.slice(0, pos)}${subStr}${str.slice(pos)}`; +export const clone = (object: T): T => { + return deepClone(object as CloneableData) as T +} + +/** + * Detects whether the given value is an asynchronous function or not. + * + * @param fn - Unknown value. + * @returns `true` if `fn` was an asynchronous function, otherwise `false`. + * @internal + */ +export const isAsyncFunction = (fn: unknown): fn is (...args: unknown[]) => Promise => { + return typeof fn === 'function' && fn.constructor.name === 'AsyncFunction' +} - /** - * @param retryNumber - the number of retries that have already been attempted - * @returns delay in milliseconds - */ - public static exponentialDelay(retryNumber = 0): number { - const delay = Math.pow(2, retryNumber) * 100; - const randomSum = delay * 0.2 * Utils.secureRandom(); // 0-20% of the delay - return delay + randomSum; +export const isObject = (value: unknown): value is object => { + return value != null && typeof value === 'object' && !Array.isArray(value) +} + +export const isEmptyObject = (object: object): object is EmptyObject => { + if (object.constructor !== Object) { + return false + } + // Iterates over the keys of an object, if + // any exist, return false. + // eslint-disable-next-line no-unreachable-loop + for (const _ in object) { + return false } + return true +} - public static async promiseWithTimeout( - promise: Promise, - timeoutMs: number, - timeoutError: Error, - timeoutCallback: () => void = () => { - /* This is intentional */ - } - ): Promise { - // Create a timeout promise that rejects in timeout milliseconds - const timeoutPromise = new Promise((_, reject) => { - setTimeout(() => { - timeoutCallback(); - reject(timeoutError); - }, timeoutMs); - }); - - // Returns a race between timeout promise and the passed promise - return Promise.race([promise, timeoutPromise]); - } - - /** - * Generate a cryptographically secure random number in the [0,1[ range - * - * @returns - */ - public static secureRandom(): number { - return crypto.randomBytes(4).readUInt32LE() / 0x100000000; - } - - public static JSONStringifyWithMapSupport( - obj: Record | Record[] | Map, - space?: number - ): string { - return JSON.stringify( - obj, - (key, value: Record) => { - if (value instanceof Map) { - return { - dataType: 'Map', - value: [...value], - }; +export const hasOwnProp = (value: unknown, property: PropertyKey): boolean => { + return isObject(value) && Object.hasOwn(value, property) +} + +export const isCFEnvironment = (): boolean => { + return env.VCAP_APPLICATION != null +} + +const isString = (value: unknown): value is string => { + return typeof value === 'string' +} + +export const isEmptyString = (value: unknown): value is '' | undefined | null => { + return value == null || (isString(value) && value.trim().length === 0) +} + +export const isNotEmptyString = (value: unknown): value is string => { + return isString(value) && value.trim().length > 0 +} + +export const isEmptyArray = (value: unknown): value is never[] => { + return Array.isArray(value) && value.length === 0 +} + +export const isNotEmptyArray = (value: unknown): value is unknown[] => { + return Array.isArray(value) && value.length > 0 +} + +export const insertAt = (str: string, subStr: string, pos: number): string => + `${str.slice(0, pos)}${subStr}${str.slice(pos)}` + +/** + * Computes the retry delay in milliseconds using an exponential backoff algorithm. + * + * @param retryNumber - the number of retries that have already been attempted + * @param delayFactor - the base delay factor in milliseconds + * @returns delay in milliseconds + */ +export const exponentialDelay = (retryNumber = 0, delayFactor = 100): number => { + const delay = Math.pow(2, retryNumber) * delayFactor + const randomSum = delay * 0.2 * secureRandom() // 0-20% of the delay + return delay + randomSum +} + +/** + * Generates a cryptographically secure random number in the [0,1[ range + * + * @returns A number in the [0,1[ range + */ +export const secureRandom = (): number => { + return getRandomValues(new Uint32Array(1))[0] / 0x100000000 +} + +export const JSONStringifyWithMapSupport = ( + object: Record | Array> | Map, + space?: number +): string => { + return JSON.stringify( + object, + (_, value: Record) => { + if (value instanceof Map) { + return { + dataType: 'Map', + value: [...value] } - return value; - }, - space - ); - } - - /** - * Convert websocket error code to human readable string message - * - * @param code - websocket error code - * @returns human readable string message - */ - public static getWebSocketCloseEventStatusString(code: number): string { - if (code >= 0 && code <= 999) { - return '(Unused)'; - } else if (code >= 1016) { - if (code <= 1999) { - return '(For WebSocket standard)'; - } else if (code <= 2999) { - return '(For WebSocket extensions)'; - } else if (code <= 3999) { - return '(For libraries and frameworks)'; - } else if (code <= 4999) { - return '(For applications)'; } + return value + }, + space + ) +} + +/** + * Converts websocket error code to human readable string message + * + * @param code - websocket error code + * @returns human readable string message + */ +export const getWebSocketCloseEventStatusString = (code: number): string => { + if (code >= 0 && code <= 999) { + return '(Unused)' + } else if (code >= 1016) { + if (code <= 1999) { + return '(For WebSocket standard)' + } else if (code <= 2999) { + return '(For WebSocket extensions)' + } else if (code <= 3999) { + return '(For libraries and frameworks)' + } else if (code <= 4999) { + return '(For applications)' } - if (!Utils.isUndefined(WebSocketCloseEventStatusString[code])) { - return WebSocketCloseEventStatusString[code] as string; + } + if ( + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + WebSocketCloseEventStatusString[code as keyof typeof WebSocketCloseEventStatusString] != null + ) { + return WebSocketCloseEventStatusString[code as keyof typeof WebSocketCloseEventStatusString] + } + return '(Unknown)' +} + +export const isArraySorted = (array: T[], compareFn: (a: T, b: T) => number): boolean => { + for (let index = 0; index < array.length - 1; ++index) { + if (compareFn(array[index], array[index + 1]) > 0) { + return false + } + } + return true +} + +// eslint-disable-next-line @typescript-eslint/no-explicit-any +export const once = ( + fn: (...args: A) => R, + context: T +): ((...args: A) => R) => { + let result: R + return (...args: A) => { + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + if (fn != null) { + result = fn.apply(context, args) + ;(fn as unknown as undefined) = (context as unknown as undefined) = undefined } - return '(Unknown)'; + return result } } + +export const min = (...args: number[]): number => + args.reduce((minimum, num) => (minimum < num ? minimum : num), Infinity) + +export const max = (...args: number[]): number => + args.reduce((maximum, num) => (maximum > num ? maximum : num), -Infinity) + +export const throwErrorInNextTick = (error: Error): void => { + nextTick(() => { + throw error + }) +}