topkat-utils 1.3.23 → 1.3.25

package/src/logger-utils.ts

@@ -27,9 +27,9 @@ export const logger = {
     /**
      * @param {String[]|String} inputLogs
      */
-    toHtml(inputLogs = [...logger.raw]) {
+    toHtml(inputLogs = [...logger.raw] as string[]) {
         if (!Array.isArray(inputLogs)) inputLogs = [inputLogs]
-        const code2css = {
+        const code2css: Record<string, any> = {
             2: `opacity:.5`, // dim
             32: `color:#679933`, // green
             31: `color:#A8383B`, // red
@@ -54,12 +54,18 @@ export const logger = {
         })
         return `<div style='color:#ccc'>${htmlLogs}<br></div>`
     },
-    toText(inputLogs = [...logger.raw]) {
+    toText(inputLogs = [...logger.raw] as string[]) {
         const str = Array.isArray(inputLogs) ? inputLogs.join('\n') : inputLogs
         return str.replace(/\x1b\[.*?m/g, '')
     },
     raw: [] as string[],
     json: [] as string[],
+} as {
+    log(str: string, level?: LogLevels): void
+    toHtml(inputLogs?: string[]): string
+    toText(inputLogs?: string[]): string
+    raw: string[]
+    json: string[]
 }
 
 /**
@@ -70,23 +76,23 @@ export const logger = {
 // * or C.gradientize(myLongString)
 */
 export const C = {
-    dim: str => C.output(2, str), // opacity 0.5
-    green: str => C.output(32, str),
-    red: str => C.output(31, str),
-    yellow: str => C.output(33, str),
-    grey: str => C.output(2, str),
-    magenta: str => C.output(35, str),
-    cyan: str => C.output(36, str),
-    blue: str => C.output(34, str),
-    primary: str => {
+    dim: (str: string) => C.output(2, str), // opacity 0.5
+    green: (str: string) => C.output(32, str),
+    red: (str: string) => C.output(31, str),
+    yellow: (str: string) => C.output(33, str),
+    grey: (str: string) => C.output(2, str),
+    magenta: (str: string) => C.output(35, str),
+    cyan: (str: string) => C.output(36, str),
+    blue: (str: string) => C.output(34, str),
+    primary: (str: string) => {
         const primary: Color = configFn()?.terminal?.theme?.primary
         return C.rgb(...primary) + str + C.reset
     },
     reset: '\x1b[0m',
-    output: (code, str = '') => configFn()?.terminal?.noColor ? str : `\x1b[${code}m${str}\x1b[0m`,
+    output: (code: number, str = '') => configFn()?.terminal?.noColor ? str : `\x1b[${code}m${str}\x1b[0m`,
     // true RGB colors B-*
-    rgb: (r, g = 0, b = 0) => configFn()?.terminal?.noColor || !isset(r, g, b) ? '' : `\x1b[38;2;${r};${g};${b}m`,
-    bg: (r?, g?, b?) => configFn()?.terminal?.noColor || !isset(r, g, b) ? '' : `${'\x1b['}48;2;${r};${g};${b}m`,
+    rgb: (r: number, g = 0, b = 0) => configFn()?.terminal?.noColor || !isset(r, g, b) ? '' : `\x1b[38;2;${r};${g};${b}m`,
+    bg: (r?: number, g?: number, b?: number) => configFn()?.terminal?.noColor || !isset(r, g, b) ? '' : `${'\x1b['}48;2;${r};${g};${b}m`,
     /** Output a line of title */
     line(title = '', length = configFn()?.terminal?.theme?.pageWidth, clr = configFn()?.terminal?.theme?.primary, char = '=') {
         this.log('\u00A0\n' + this.rgb(...clr) + (title + ' ').padEnd(length || 0, char) + this.reset + '\u00A0\n')
@@ -94,7 +100,7 @@ export const C = {
     /** Eg: ['cell1', 'cell2', 'cell3'], [25, 15] will start cell2 at 25 and cell 3 at 25 + 15
      * @param {Array} limits default divide the viewport
      */
-    cols(strings, limits: number[] = [], clr = configFn()?.terminal?.theme?.fontColor) {
+    cols(strings: string[], limits: number[] = [], clr = configFn()?.terminal?.theme?.fontColor) {
 
         if (!limits.length) {
             const colWidth = Math.round(configFn()?.terminal?.theme.pageWidth / strings.length)
@@ -109,58 +115,40 @@ export const C = {
         this.logClr(str, clr)
     },
     /** Console log alias */
-    log(...stringsCtxMayBeFirstParam) {
-        stringsCtxMayBeFirstParam.forEach(str => this.logClr(str))
+    log(...stringsCtxMayBeFirstParam: any[]) {
+        stringsCtxMayBeFirstParam.forEach((str: string) => this.logClr(str))
     },
-    logClr(str, clr = configFn()?.terminal?.theme?.fontColor) {
+    logClr(str: string, clr = configFn()?.terminal?.theme?.fontColor) {
         if (!isset(str)) return
         str = (typeof clr !== 'undefined' ? this.rgb(...clr) : '') + str.toString().replace(/\n/g, '\n' + (typeof clr !== 'undefined' ? this.rgb(...clr) : ''))
         logger.log(str + this.reset, 'info')
     },
-    info(...str) {
+    info(...str: string[]) {
         str.forEach((s, i) => {
             if (i === 0) this.logClr('ⓘ  ' + s, configFn()?.terminal?.theme?.primary)
             else this.log(this.dimStrSplit(s))
         })
         this.log(' ')
     },
-    success(...str) {
+    success(...str: string[]) {
         str.forEach((s, i) => {
             if (i === 0) this.log(this.green('✓  ' + s))
             else this.log(this.dimStrSplit(s))
         })
     },
     /** First param **false** to avoid logging stack trace */
-    error: (...errors) => logErrPrivate('error', [255, 0, 0], ...errors),
+    error: (...errors: any[]) => logErrPrivate('error', [255, 0, 0], ...errors),
     /** First param **false** to avoid logging stack trace */
-    warning: (...str) => logErrPrivate('warn', [255, 122, 0], ...str),
-    customError: (color, ...str) => logErrPrivate('error', color, ...str),
-    customWarning: (color, ...str) => logErrPrivate('warn', color, ...str),
-    applicationError: (color, ...str) => logErrPrivate('warn', color, ...str),
-    warningLight: (_, ...str) => logErrPrivate('warn', [196, 120, 52], ...str),
-    dimStrSplit(...logs) {
+    warning: (...str: string[]) => logErrPrivate('warn', [255, 122, 0], ...str),
+    customError: (color: Color, ...str: string[]) => logErrPrivate('error', color, ...str),
+    customWarning: (color: Color, ...str: string[]) => logErrPrivate('warn', color, ...str),
+    applicationError: (color: Color, ...str: string[]) => logErrPrivate('warn', color, ...str),
+    warningLight: (_: any, ...str: string[]) => logErrPrivate('warn', [196, 120, 52], ...str),
+    dimStrSplit(...logs: string[]) {
         const logsStr: string[] = []
         logs.filter(isset).forEach(log => log.toString().split('\n').forEach(line => line && logsStr.push(this.dim(`    ${line}`))))
         return logsStr.join('\n')
     },
-    notifShow() {
-        console.log('\n\u00A0')
-        this.notifications.forEach(fn => fn())
-        this.notifications = []
-        console.log('\n\u00A0')
-    },
-    /** Keep in memory the logs to show when needed with C.notifShow()
-     * Ex: C.notification('info', str); */
-    notification(type, ...messages) {
-        this.notifications.push(() => {
-            if (isset(this[type])) {
-                this[type](...messages)
-            } else {
-                this.warning('Wrong param for C.notification')
-            }
-        })
-    },
-    notifications: [] as any[], // fn array
     /** Gratientize lines of text (separated by \n) */
     gradientize(str = '', rgb1 = configFn()?.terminal?.theme?.shade1, rgb2 = configFn()?.terminal?.theme?.shade2, bgRgb = configFn()?.terminal?.theme?.bgColor, paddingY = 2) {
 
@@ -177,7 +165,7 @@ export const C = {
             }, '') +
             padLine.repeat(paddingY))
     },
-    debugModeLog(title, ...string) {
+    debugModeLog(title: string, ...string: string[]) {
         this.logClr('🐞 ' + title, configFn()?.terminal?.theme?.debugModeColor)
         this.log(this.dimStrSplit(...string))
     },
@@ -191,7 +179,7 @@ export const C = {
     }
 }
 
-function logErrPrivate(level: NotInfoLogLevel, color: Color, ...errors) {
+function logErrPrivate(level: NotInfoLogLevel, color: Color, ...errors: any[]) {
     const { isProd } = configFn()
 
     if (errors.length === 1 && typeof errors[0]?.log === 'function') return errors[0].log()
@@ -201,7 +189,7 @@ function logErrPrivate(level: NotInfoLogLevel, color: Color, ...errors) {
     const symbol = level === 'error' ? '✘ ' : '⚠ '
     if (errors.length > 1 && !isset(errors[0])) errors.shift() // remove first empty object
 
-    const getStringFromErr = (err, i) => {
+    const getStringFromErr = (err: any, i: number) => {
         if (!isset(err)) return ''
         else if (typeof err === 'string') {
             if (i === 0) return C.rgb(...color) + symbol + err + C.reset
@@ -243,7 +231,7 @@ function logErrPrivate(level: NotInfoLogLevel, color: Color, ...errors) {
     }
 }
 
-function stringifyInstanceOfError(err, type = 'error', color: Color = [255, 0, 0], level = 0) { // level = keep track of recursions
+function stringifyInstanceOfError(err: any, type: NotInfoLogLevel = 'error', color: Color = [255, 0, 0], level = 0): { str: string, stackTrace?: string } { // level = keep track of recursions
     if (level > 5) return { str: '' }
     let str = ''
     let stackTrace
@@ -261,7 +249,7 @@ function stringifyInstanceOfError(err, type = 'error', color: Color = [255, 0, 0
     return { str, stackTrace }
 }
 
-function stringifyExtraInfos(extraInfoOriginal, type, color, level = 0) {
+function stringifyExtraInfos(extraInfoOriginal: Record<string, any>, type: NotInfoLogLevel, color: Color, level = 0) {
     let stackTrace
     const originalError = [C.dim(`ORIGINAL ERROR ${'-'.repeat(39)}\n`)]
     if (extraInfoOriginal instanceof Error) { // case where error is passed directly to extraInfos
@@ -336,7 +324,7 @@ export class cliLoadingSpinner {
         this.animFrames = anims[type].frames
         this.activeProcess = activeProcess
     }
-    start(msg) {
+    start(msg: string) {
         this.frameNb = 0
         this.progressMessage = msg
         this.interval = setInterval(() => {

package/src/loop-utils.ts

@@ -31,7 +31,7 @@ export function forI<T extends any[] | any>(
         /** Current iteration index (0-based) */
         number: number,
         /** Result from previous iteration */
-        previousValue,
+        previousValue: any,
         /** Array of all previous results */
         arrayOfPreviousValues: any[]
     ) => T
@@ -58,7 +58,7 @@ export function forI<T extends any[] | any>(
  * ```
  * // Returns: [1, 1, 2, 3, 5, 8, 13, 21]
  */
-export async function forIasync<T extends any[] | any>(nbIterations: number, callback: (number) => T): Promise<T[]> {
+export async function forIasync<T extends any[] | any>(nbIterations: number, callback: (number: number) => T): Promise<T[]> {
     const results: any[] = []
     for (let i = 0; i < nbIterations; i++) {
         results.push(await callback(i))
@@ -67,7 +67,7 @@ export async function forIasync<T extends any[] | any>(nbIterations: number, cal
 }
 
 
-export type RecursiveCallback = (item: any, addr: string, lastElementKey: string | number, parent: ObjectGeneric | any[]) => false | any
+export type RecursiveCallback = (item: any, addr: string, lastElementKey: string | number, parent?: ObjectGeneric | any[]) => false | any
 export type RecursiveConfig = {
     disableCircularDependencyRemoval?: boolean
     isObjectTestFunction?: (item: any) => boolean
@@ -98,7 +98,7 @@ export async function recursiveGenericFunction(
     addr$ = '',
     /** Technical field */
     lastElementKey: string | number = '',
-    parent?,
+    parent?: Record<string, any>,
     techFieldToAvoidCircularDependency: any[] = []
 ) {
     err500IfNotSet({ callback })
@@ -141,7 +141,7 @@ export async function recursiveGenericFunction(
  * NOTE: will remove circular references
  * /!\ check return values
  */
-export function recursiveGenericFunctionSync(item: ObjectGeneric | any[], callback: RecursiveCallback, config: RecursiveConfig = {}, addr$ = '', lastElementKey: string | number = '', parent?, techFieldToAvoidCircularDependency: any[] = []) {
+export function recursiveGenericFunctionSync(item: ObjectGeneric | any[], callback: RecursiveCallback, config: RecursiveConfig = {}, addr$ = '', lastElementKey: string | number = '', parent?: Record<string, any>, techFieldToAvoidCircularDependency: any[] = []) {
     err500IfNotSet({ callback })
 
     if (!config.isObjectTestFunction) config.isObjectTestFunction = isObject

package/src/mongo-utils.ts

@@ -17,7 +17,7 @@ export function getId(obj: any): string | undefined {
  * @param {Object} filterB
  * @param {Boolean} assignToFilterA defualt false: if true, it will modify filterA, else it will return merged filters as a new object
  */
-export function mongoFilterMerger(filterA, filterB, assignToFilterA = false) {
+export function mongoFilterMerger(filterA: any, filterB: any, assignToFilterA = false) {
     if (isset(filterA.$and) && isset(filterB.$and)) {
         filterA.$and.push(...filterB.$and)
         delete filterB.$and

package/src/object-utils.ts

@@ -29,7 +29,7 @@ export function simpleObjectMaskOrSelect<Obj extends ObjectGeneric>(
         keysToMask.forEach(keyNameToDelete => delete object[keyNameToDelete])
         return object
     } else {
-        return allKeys.reduce((newObject, key) => {
+        return allKeys.reduce((newObject: Record<string, any>, key) => {
             if (!keysToMask.includes(key)) newObject[key] = object[key]
             return newObject
         }, {}) as Obj
@@ -93,7 +93,7 @@ export function findByAddressAll<ReturnAddresses extends boolean = false>(
 /** Enforce writing subItems. Eg: user.name.blah will ensure all are set until the writing of the last item
  * NOTE: doesn't work when parent is array
  */
-export function objForceWrite<MainObj extends Record<string, any>>(obj: MainObj, addr: string, item, options: { doNotWriteFinalValue?: boolean } = {}): MainObj {
+export function objForceWrite<MainObj extends Record<string, any>>(obj: MainObj, addr: string, item: any, options: { doNotWriteFinalValue?: boolean } = {}): MainObj {
     const { doNotWriteFinalValue = false } = options
     const writeFinalValue = !doNotWriteFinalValue
 
@@ -129,13 +129,13 @@ export const objForceWritePath = forcePathInObject
  * if user.name.blah has a value it will not change it.
  * NOTE: doesn't work when parent is array
  */
-export function objForceWriteIfNotSet<MainObj extends Record<string, any>>(obj: MainObj, addr: string, item): MainObj {
+export function objForceWriteIfNotSet<MainObj extends Record<string, any>>(obj: MainObj, addr: string, item: any): MainObj {
     if (!isset(findByAddress(obj, addr))) return objForceWrite(obj, addr, item)
     else return obj
 }
 
 /** Merge mixins into class. Use it in the constructor like: mergeMixins(this, {myMixin: true}) */
-export function mergeMixins(that, ...mixins) {
+export function mergeMixins(that: any, ...mixins: any[]) {
     mixins.forEach(mixin => {
         for (const method in mixin) {
             that[method] = mixin[method]
@@ -187,7 +187,7 @@ export function deepClone<MainObj extends Record<string, any>>(obj: MainObj, cac
  * @param {Object} obj the object on which we want to filter the keys
  * @param {function} filterFunc function that returns true if the key match the wanted criteria
  */
-export function filterKeys<MainObj extends Record<string, any>>(obj: MainObj, filter): MainObj {
+export function filterKeys<MainObj extends Record<string, any>>(obj: MainObj, filter: any): MainObj {
     const clone = cloneObject(obj)
     recursiveGenericFunctionSync(obj, (_, addr, lastElementKey) => {
         if (!filter(lastElementKey)) deleteByAddress(clone, addr.split('.'))
@@ -199,7 +199,7 @@ export function filterKeys<MainObj extends Record<string, any>>(obj: MainObj, fi
  * @param {Array} addrArr addressArray on which to delete the property
  */
 export function deleteByAddress(obj: object, addr: string | string[]) {
-    let current = obj
+    let current = obj as Record<string, any>
     const addrArr = Array.isArray(addr) ? addr : addr.split('.')
     for (let i = 0; i < addrArr.length; i++) {
         const currentAddr = addrArr[i].replace(/(\[|\])/g, '')
@@ -227,9 +227,9 @@ export function readOnly<MainObj extends Record<string, any>>(o: MainObj): { rea
 }
 
 /** Fields of the object can be created BUT NOT reassignated */
-export function reassignForbidden(o) {
+export function reassignForbidden(o: Record<string, any>) {
     return new Proxy(o, {
-        defineProperty: function (that, key, value) {
+        defineProperty: function (that: Record<string, any>, key: string, value) {
             if (key in that) throw new DescriptiveError(`Cannot reassign the property ${key.toString()} of this object`, { code: 500 })
             else {
                 that[key] = value
@@ -243,9 +243,9 @@ export function reassignForbidden(o) {
 }
 
 /** All fileds and subFields of the object will become readOnly */
-export function readOnlyRecursive(object) {
+export function readOnlyRecursive(object: Record<string, any>) {
     recursiveGenericFunctionSync(object, (item, _, lastElementKey, parent) => {
-        if (typeof item === 'object') parent[lastElementKey] = readOnly(item)
+        if (typeof item === 'object' && parent) (parent as any)[lastElementKey] = readOnly(item)
     })
     return object
 }
@@ -253,7 +253,7 @@ export function readOnlyRecursive(object) {
 /** @deprecated use readOnlyRecursive instead */
 export const readOnlyForAll = readOnlyRecursive
 
-export function objFilterUndefinedRecursive(obj) {
+export function objFilterUndefinedRecursive(obj: Record<string, any>) {
     if (obj) {
         const flattenedObj = flattenObject(obj)
         Object.keys(flattenedObj).forEach(key => {
@@ -265,8 +265,8 @@ export function objFilterUndefinedRecursive(obj) {
     } else return obj
 }
 
-export function sortObjKeyAccordingToValue(unorderedObj, ascending = true) {
-    const orderedObj = {}
+export function sortObjKeyAccordingToValue(unorderedObj: Record<string, any>, ascending = true) {
+    const orderedObj = {} as Record<string, any>
     const sortingConst = ascending ? 1 : -1
     Object.keys(unorderedObj)
         .sort((keyA, keyB) => unorderedObj[keyA] < unorderedObj[keyB] ? sortingConst : -sortingConst)
@@ -285,7 +285,7 @@ export function sortObjKeyAccordingToValue(unorderedObj, ascending = true) {
 export function ensureObjectProp<MainObj extends Record<string, any>, Addr extends string>(
     obj: MainObj,
     addr: Addr,
-    defaultValue,
+    defaultValue: any,
     callback: (o: any) => any
 ): MainObj[Addr] {
     err500IfNotSet({ obj, addr, defaultValue, callback })
@@ -309,7 +309,7 @@ export function mergeDeep<
 >(...objects: [O1, O2?, O3?, O4?, O5?, O6?]): O1 & O2 & O3 & O4 & O5 & O6 {
     return mergeDeepConfigurable(
         (previousVal, currentVal) => [...previousVal, ...currentVal].filter((elm, i, arr) => arr.indexOf(elm) === i),
-        (previousVal, currentVal) => mergeDeep(previousVal, currentVal),
+        (previousVal: any, currentVal: any) => mergeDeep(previousVal, currentVal),
         undefined,
         ...objects
     )
@@ -329,7 +329,7 @@ export function mergeDeepOverrideArrays<
 >(...objects: [O1, O2?, O3?, O4?, O5?, O6?]): O1 & O2 & O3 & O4 & O5 & O6 {
     return mergeDeepConfigurable(
         undefined,
-        (previousVal, currentVal) => mergeDeepOverrideArrays(previousVal, currentVal),
+        (previousVal: any, currentVal: any) => mergeDeepOverrideArrays(previousVal, currentVal),
         undefined,
         ...objects
     )
@@ -351,11 +351,11 @@ export function mergeDeepConfigurable<
     O5 extends Record<string, any> = Record<string, any>,
     O6 extends Record<string, any> = Record<string, any>,
 >(
-    replacerForArrays = (_, curr) => curr, replacerForObjects,
-    replacerDefault = (_, curr) => curr,
+    replacerForArrays = (_: any, curr: any) => curr, replacerForObjects: any,
+    replacerDefault = (_: any, curr: any) => curr,
     ...objects: [O1, O2?, O3?, O4?, O5?, O6?]
 ): O1 & O2 & O3 & O4 & O5 & O6 {
-    return objects.reduce((actuallyMerged, obj) => {
+    return objects.reduce((actuallyMerged: Record<string, any>, obj) => {
         if (obj && typeof obj === 'object') Object.keys(obj).forEach(key => {
             const previousVal = actuallyMerged[key]
             const currentVal = obj[key]
@@ -376,11 +376,11 @@ export function mergeDeepConfigurable<
 /** { a: {b:2}} => {'a.b':2} useful for translations
  * NOTE: will remove circular references
  */
-export function flattenObject(data, config: { withoutArraySyntax?: boolean, withArraySyntaxMinified?: boolean } = {}): Record<string, any> {
+export function flattenObject(data: any, config: { withoutArraySyntax?: boolean, withArraySyntaxMinified?: boolean } = {}): Record<string, any> {
     const { withoutArraySyntax = false, withArraySyntaxMinified = false } = config
-    const result = {}
+    const result = {} as Record<string, any>
     const seenObjects: any[] = [] // avoidCircular reference to infinite loop
-    const recurse = (cur, prop) => {
+    const recurse = (cur: any, prop: string) => {
         if (Array.isArray(cur)) {
             const l = cur.length
             let i = 0

package/src/regexp-utils.ts

@@ -33,10 +33,10 @@ export function firstMatch(str: string, regExp: RegExp): string | undefined { re
  * Eg: [ [full, match1, m2], [f, m1, m2]... ]
  * NOTE: the G flag will be appended to regexp
  */
-export function allMatches(str: string, reg: RegExp): string[] {
+export function allMatches(str: string, reg: RegExp) {
     let i = 0
-    let matches
-    const arr: string[] = []
+    let matches: RegExpExecArray | null
+    const arr: (RegExpExecArray | null)[] = []
     if (typeof str !== 'string') C.error('Not a string provided as first argument for allMatches()')
     else {
         reg = new RegExp(reg, 'g')

package/src/remove-circular-json-stringify.ts

@@ -1,10 +1,10 @@
 
 
 /** Best way to stringify a value! Default indent: 2 */
-export function removeCircularJSONstringify(object, indent = 2) {
+export function removeCircularJSONstringify(object: Record<string, any>, indent = 2) {
     const getCircularReplacer = () => {
         const seen = new WeakSet()
-        return (_, value) => {
+        return (_: any, value: any) => {
             if (typeof value === 'object' && value !== null) {
                 if (seen.has(value)) {
                     return

package/src/string-utils.ts

@@ -76,7 +76,7 @@ export function getValuesBetweenSeparator(str: string, separator: string, remove
  * @param ignoreBetweenOpen default ['\'', '`', '"', '/'], when reaching an opening char, it will ignore all until it find the corresponding closing char
  * @param ignoreBetweenClose default ['\'', '`', '"', '/'] list of corresponding closing chars
  */
-export function getValuesBetweenStrings(str: string, openingOrSeparator, closing, ignoreBetweenOpen = ['\'', '`', '"', '/'], ignoreBetweenClose = ['\'', '`', '"', '/'], removeTrailingSpaces = true) {
+export function getValuesBetweenStrings(str: string, openingOrSeparator: string, closing?: string, ignoreBetweenOpen = ['\'', '`', '"', '/'], ignoreBetweenClose = ['\'', '`', '"', '/'], removeTrailingSpaces = true) {
     err500IfEmptyOrNotSet({ openingOrSeparator, str })
 
     str = str.replace(/<</g, '§§"').replace(/>>/g, '"§§')
@@ -129,7 +129,7 @@ export function getValuesBetweenStrings(str: string, openingOrSeparator, closing
 
     pushActualValue()
 
-    const replaceValz = arr => arr.map(v => v.replace(/§§"/g, '<<').replace(/"§§/g, '>>')).filter(v => v)
+    const replaceValz = (arr: string[]) => arr.map(v => v.replace(/§§"/g, '<<').replace(/"§§/g, '>>')).filter(v => v)
 
     return { inner: replaceValz(arrayValues), outer: replaceValz(betweenArray) }
 }
@@ -240,7 +240,7 @@ export function miniTemplater(content: string, varz: ObjectGeneric, options: Par
 
 
 /** Clean output for outside world. All undefined / null / NaN / Infinity values are changed to '-' */
-export function cln(val, replacerInCaseItIsUndefinNaN = '-') { return ['undefined', undefined, 'indéfini', 'NaN', NaN, Infinity, null].includes(val) ? replacerInCaseItIsUndefinNaN : val }
+export function cln(val: any, replacerInCaseItIsUndefinNaN = '-') { return ['undefined', undefined, 'indéfini', 'NaN', NaN, Infinity, null].includes(val) ? replacerInCaseItIsUndefinNaN : val }
 
 export function nbOccurenceInString(baseString: string, searchedString: string, allowOverlapping: boolean = false) {
 

package/src/tests-utils.ts

@@ -16,7 +16,7 @@ export const restTestMini = {
         restTestMini.lastErrors = []
         restTestMini.throwOnErr = throwOnErr
     },
-    newErr(err) {
+    newErr(err: any) {
         restTestMini.nbError++
         restTestMini.lastErrors.push(err)
         if (restTestMini.throwOnErr) throw new Error(err)

package/src/timer-utils.ts

@@ -7,9 +7,9 @@ import { DescriptiveError } from './error-utils'
 import { round2 } from './math-utils'
 
 
-export async function timeout(ms, fn = () => { /* */ }) { return new Promise(res => setTimeout(res, ms)).then(fn) }
+export async function timeout(ms: number, fn = () => { /* */ }) { return new Promise(res => setTimeout(res, ms)).then(fn) }
 
-export async function runAsync(callback, milliseconds$ = 1) { return timeout(milliseconds$, callback) }
+export async function runAsync(callback: () => any, milliseconds$ = 1) { return timeout(milliseconds$, callback) }
 
 /**
  *
@@ -18,7 +18,7 @@ export async function runAsync(callback, milliseconds$ = 1) { return timeout(mil
  * @param {Boolean|String} errorAfterNSeconds default:true output an error in case of timeout, can be the displayed error message
  * @param {*} cliOutput write a cli progress to show that a process is running
  */
-export async function waitUntilTrue(callback, timeoutSec = 10, errorAfterNSeconds = true, cliOutput = true) {
+export async function waitUntilTrue(callback: () => any, timeoutSec = 10, errorAfterNSeconds = true, cliOutput = true) {
     let generalTimeout = true
     let step = 3
     const errMess = typeof errorAfterNSeconds === 'string' ? 'Timeout: ' + errorAfterNSeconds : 'Timeout for waitUntilTrue() callback'
@@ -42,7 +42,7 @@ let isExecuting = false
  * @param {Number} time default: 500ms;
  * @param {Function} errorCallback default: e => C.error(e)
  */
-export async function executeInDelayedLoop(callback, time = 500, errorCallback = e => C.error(e)) {
+export async function executeInDelayedLoop(callback: () => any, time = 500, errorCallback = (e: any) => C.error(e)) {
     delayedLoopParams.push([callback, time, errorCallback])
     if (isExecuting) return
     isExecuting = true

package/src/transaction-utils.spec.ts

@@ -9,7 +9,7 @@ import { timeout } from './timer-utils'
 describe('TRANSACTION TEST', () => {
     const statusArr = [] as number[]
 
-    const asyncCallback = i => async () => {
+    const asyncCallback = (i: number) => async () => {
         await timeout(1000)
         statusArr.push(i)
     }

package/src/transaction-utils.ts

@@ -5,8 +5,8 @@ import { isset } from './isset'
 import { C } from './logger-utils'
 import { timeout } from './timer-utils'
 
-const transactionRunning = { __default: false }
-const queue = { __default: [] }
+const transactionRunning = { __default: false } as Record<string, boolean>
+const queue = { __default: [] } as Record<string, any[]>
 
 /** Allow to perform async functions in a defined order
  * This adds the callback to a queue and is resolved when ALL previous callbacks with same name are executed
@@ -16,7 +16,7 @@ const queue = { __default: [] }
  * @param {Number} timeout default: 120000 (120s) will throw an error if transaction time is higher that this amount of ms
  * @returns {Promise}
  */
-export async function transaction(name, asyncCallback, timeout = 120000, doNotThrow = false) {
+export async function transaction(name: string, asyncCallback: () => any, timeout = 120000, doNotThrow = false) {
     if (typeof name === 'function') {
         asyncCallback = name
         name = '__default'
@@ -45,7 +45,7 @@ export async function transaction(name, asyncCallback, timeout = 120000, doNotTh
     })
 }
 
-export async function removeItemFromQueue(name) {//        meoww!
+export async function removeItemFromQueue(name: string) {//        meoww!
     if (transactionRunning[name] === true) return //       v
     transactionRunning[name] = true //                A  A       /\
     while (queue[name].length) await queue[name].shift()() //    ||
@@ -54,7 +54,7 @@ export async function removeItemFromQueue(name) {//        meoww!
 //                                                        11    11
 
 /** Wait for a transaction to complete without creating a new transaction */
-export async function waitForTransaction(transactionName, forceReleaseInSeconds = 30) {
+export async function waitForTransaction(transactionName: string, forceReleaseInSeconds = 30) {
     let brk = false
     setTimeout(() => brk = true, forceReleaseInSeconds * 1000)
     while (isset(transactionRunning[transactionName]) && transactionRunning[transactionName] === true) {