1 import { getRandomValues
, randomBytes
, randomInt
, randomUUID
} from
'node:crypto'
2 import { env
, nextTick
} from
'node:process'
10 millisecondsToMinutes
,
11 millisecondsToSeconds
,
16 import { Constants
} from
'./Constants.js'
17 import { type TimestampedData
, WebSocketCloseEventStatusString
} from
'../types/index.js'
19 export const logPrefix
= (prefixString
= ''): string => {
20 return `${new Date().toLocaleString()}${prefixString}`
23 export const generateUUID
= (): string => {
27 export const validateUUID
= (uuid
: string): boolean => {
28 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
)
31 export const sleep
= async (milliSeconds
: number): Promise
<NodeJS
.Timeout
> => {
32 return await new Promise
<NodeJS
.Timeout
>((resolve
) =>
33 setTimeout(resolve
as () => void, milliSeconds
)
37 export const formatDurationMilliSeconds
= (duration
: number): string => {
38 duration
= convertToInt(duration
)
40 throw new RangeError('Duration cannot be negative')
42 const days
= Math.floor(duration
/ (24 * 3600 * 1000))
43 const hours
= Math.floor(millisecondsToHours(duration
) - days
* 24)
44 const minutes
= Math.floor(
45 millisecondsToMinutes(duration
) - days
* 24 * 60 - hoursToMinutes(hours
)
47 const seconds
= Math.floor(
48 millisecondsToSeconds(duration
) -
50 hoursToSeconds(hours
) -
51 minutesToSeconds(minutes
)
53 if (days
=== 0 && hours
=== 0 && minutes
=== 0 && seconds
=== 0) {
54 return formatDuration({ seconds
}, { zero
: true })
56 return formatDuration({
64 export const formatDurationSeconds
= (duration
: number): string => {
65 return formatDurationMilliSeconds(secondsToMilliseconds(duration
))
68 // More efficient time validation function than the one provided by date-fns
69 export const isValidTime
= (date
: unknown
): boolean => {
70 if (typeof date
=== 'number') {
72 } else if (isDate(date
)) {
73 return !isNaN(date
.getTime())
78 export const convertToDate
= (
79 value
: Date | string | number | null | undefined
80 ): Date | null | undefined => {
87 if (isString(value
) || typeof value
=== 'number') {
88 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
89 const valueToDate
= new Date(value
)
90 if (isNaN(valueToDate
.getTime())) {
91 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
92 throw new Error(`Cannot convert to date: '${value}'`)
98 export const convertToInt
= (value
: unknown
): number => {
102 let changedValue
: number = value
as number
103 if (Number.isSafeInteger(value
)) {
104 return value
as number
106 if (typeof value
=== 'number') {
107 return Math.trunc(value
)
109 if (isString(value
)) {
110 changedValue
= parseInt(value
as string)
112 if (isNaN(changedValue
)) {
113 throw new Error(`Cannot convert to integer: '${String(value)}'`)
118 export const convertToFloat
= (value
: unknown
): number => {
122 let changedValue
: number = value
as number
123 if (isString(value
)) {
124 changedValue
= parseFloat(value
as string)
126 if (isNaN(changedValue
)) {
127 throw new Error(`Cannot convert to float: '${String(value)}'`)
132 export const convertToBoolean
= (value
: unknown
): boolean => {
136 if (typeof value
=== 'boolean') {
138 } else if (isString(value
) && ((value
as string).toLowerCase() === 'true' || value
=== '1')) {
140 } else if (typeof value
=== 'number' && value
=== 1) {
147 export const getRandomFloat
= (max
= Number.MAX_VALUE
, min
= 0): number => {
149 throw new RangeError('Invalid interval')
151 if (max
- min
=== Infinity) {
152 throw new RangeError('Invalid interval')
154 return (randomBytes(4).readUInt32LE() / 0xffffffff) * (max
- min
) + min
157 export const getRandomInteger
= (max
= Constants
.MAX_RANDOM_INTEGER
, min
= 0): number => {
158 max
= Math.floor(max
)
159 if (min
!= null && min
!== 0) {
161 return Math.floor(randomInt(min
, max
+ 1))
163 return Math.floor(randomInt(max
+ 1))
167 * Rounds the given number to the given scale.
168 * The rounding is done using the "round half away from zero" method.
170 * @param numberValue - The number to round.
171 * @param scale - The scale to round to.
172 * @returns The rounded number.
174 export const roundTo
= (numberValue
: number, scale
: number): number => {
175 const roundPower
= Math.pow(10, scale
)
176 return Math.round(numberValue
* roundPower
* (1 + Number.EPSILON
)) / roundPower
179 export const getRandomFloatRounded
= (max
= Number.MAX_VALUE
, min
= 0, scale
= 2): number => {
180 if (min
!= null && min
!== 0) {
181 return roundTo(getRandomFloat(max
, min
), scale
)
183 return roundTo(getRandomFloat(max
), scale
)
186 export const getRandomFloatFluctuatedRounded
= (
188 fluctuationPercent
: number,
191 if (fluctuationPercent
< 0 || fluctuationPercent
> 100) {
192 throw new RangeError(
193 `Fluctuation percent must be between 0 and 100. Actual value: ${fluctuationPercent}`
196 if (fluctuationPercent
=== 0) {
197 return roundTo(staticValue
, scale
)
199 const fluctuationRatio
= fluctuationPercent
/ 100
200 return getRandomFloatRounded(
201 staticValue
* (1 + fluctuationRatio
),
202 staticValue
* (1 - fluctuationRatio
),
207 export const extractTimeSeriesValues
= (timeSeries
: TimestampedData
[]): number[] => {
208 return timeSeries
.map((timeSeriesItem
) => timeSeriesItem
.value
)
211 export const isObject
= (item
: unknown
): boolean => {
212 return item
!= null && typeof item
=== 'object' && !Array.isArray(item
)
223 | { [key
: string]: CloneableData
}
225 type FormatKey
= (key
: string) => string
227 const deepClone
= <I
extends CloneableData
, O
extends CloneableData
= I
>(
229 formatKey
?: FormatKey
,
230 refs
: Map
<I
, O
> = new Map
<I
, O
>()
232 const ref
= refs
.get(value
)
233 if (ref
!== undefined) {
236 if (Array.isArray(value
)) {
237 const clone
: CloneableData
[] = []
238 refs
.set(value
, clone
as O
)
239 for (let i
= 0; i
< value
.length
; i
++) {
240 clone
[i
] = deepClone(value
[i
], formatKey
, refs
)
244 if (value
instanceof Date) {
245 return new Date(value
.valueOf()) as O
247 if (typeof value
!== 'object' || value
=== null) {
248 return value
as unknown
as O
250 const clone
: Record
<string, CloneableData
> = {}
251 refs
.set(value
, clone
as O
)
252 for (const key
of Object.keys(value
)) {
253 clone
[typeof formatKey
=== 'function' ? formatKey(key
) : key
] = deepClone(
262 export const cloneObject
= <T
>(object
: T
): T
=> {
263 return deepClone(object
as CloneableData
) as T
266 export const hasOwnProp
= (object
: unknown
, property
: PropertyKey
): boolean => {
267 return isObject(object
) && Object.hasOwn(object
as object
, property
)
270 export const isCFEnvironment
= (): boolean => {
271 return env
.VCAP_APPLICATION
!= null
274 export const isIterable
= <T
>(obj
: T
): boolean => {
275 return obj
!= null ? typeof obj
[Symbol
.iterator
as keyof T
] === 'function' : false
278 const isString
= (value
: unknown
): boolean => {
279 return typeof value
=== 'string'
282 export const isEmptyString
= (value
: unknown
): boolean => {
283 return value
== null || (isString(value
) && (value
as string).trim().length
=== 0)
286 export const isNotEmptyString
= (value
: unknown
): boolean => {
287 return isString(value
) && (value
as string).trim().length
> 0
290 export const isUndefined
= (value
: unknown
): boolean => {
291 return value
=== undefined
294 export const isEmptyArray
= (object
: unknown
): boolean => {
295 return Array.isArray(object
) && object
.length
=== 0
298 export const isNotEmptyArray
= (object
: unknown
): boolean => {
299 return Array.isArray(object
) && object
.length
> 0
302 export const isEmptyObject
= (obj
: object
): boolean => {
303 if (obj
?.constructor
!== Object) {
306 // Iterates over the keys of an object, if
307 // any exist, return false.
308 // eslint-disable-next-line no-unreachable-loop
309 for (const _
in obj
) {
315 export const insertAt
= (str
: string, subStr
: string, pos
: number): string =>
316 `${str.slice(0, pos)}${subStr}${str.slice(pos)}`
319 * Computes the retry delay in milliseconds using an exponential backoff algorithm.
321 * @param retryNumber - the number of retries that have already been attempted
322 * @param delayFactor - the base delay factor in milliseconds
323 * @returns delay in milliseconds
325 export const exponentialDelay
= (retryNumber
= 0, delayFactor
= 100): number => {
326 const delay
= Math.pow(2, retryNumber
) * delayFactor
327 const randomSum
= delay
* 0.2 * secureRandom() // 0-20% of the delay
328 return delay
+ randomSum
332 * Generates a cryptographically secure random number in the [0,1[ range
334 * @returns A number in the [0,1[ range
336 export const secureRandom
= (): number => {
337 return getRandomValues(new Uint32Array(1))[0] / 0x100000000
340 export const JSONStringifyWithMapSupport
= (
341 obj
: Record
<string, unknown
> | Array<Record
<string, unknown
>> | Map
<unknown
, unknown
>,
344 return JSON
.stringify(
346 (_
, value
: Record
<string, unknown
>) => {
347 if (value
instanceof Map
) {
360 * Converts websocket error code to human readable string message
362 * @param code - websocket error code
363 * @returns human readable string message
365 export const getWebSocketCloseEventStatusString
= (code
: number): string => {
366 if (code
>= 0 && code
<= 999) {
368 } else if (code
>= 1016) {
370 return '(For WebSocket standard)'
371 } else if (code
<= 2999) {
372 return '(For WebSocket extensions)'
373 } else if (code
<= 3999) {
374 return '(For libraries and frameworks)'
375 } else if (code
<= 4999) {
376 return '(For applications)'
381 WebSocketCloseEventStatusString
[code
as keyof
typeof WebSocketCloseEventStatusString
]
384 return WebSocketCloseEventStatusString
[code
as keyof
typeof WebSocketCloseEventStatusString
]
389 export const isArraySorted
= <T
>(array
: T
[], compareFn
: (a
: T
, b
: T
) => number): boolean => {
390 for (let index
= 0; index
< array
.length
- 1; ++index
) {
391 if (compareFn(array
[index
], array
[index
+ 1]) > 0) {
398 // eslint-disable-next-line @typescript-eslint/no-explicit-any
399 export const once
= <T
, A
extends any[], R
>(
400 fn
: (...args
: A
) => R
,
402 ): ((...args
: A
) => R
) => {
404 return (...args
: A
) => {
406 result
= fn
.apply
<T
, A
, R
>(context
, args
)
407 ;(fn
as unknown
as undefined) = (context
as unknown
as undefined) = undefined
413 export const min
= (...args
: number[]): number =>
414 args
.reduce((minimum
, num
) => (minimum
< num
? minimum
: num
), Infinity)
416 export const max
= (...args
: number[]): number =>
417 args
.reduce((maximum
, num
) => (maximum
> num
? maximum
: num
), -Infinity)
419 export const throwErrorInNextTick
= (error
: Error): void => {