topkat-utils 1.2.32 → 1.2.34

package/src/logger-utils.ts

@@ -19,7 +19,7 @@ export const logger = {
         else console.log(str)
 
         logger.raw.push(str + `\n`)
-        logger.raw = logger.raw.slice(logger.raw.length - configFn().nbOfLogsToKeep, logger.raw.length)
+        logger.raw = logger.raw.slice(logger.raw.length - configFn()?.nbOfLogsToKeep, logger?.raw?.length)
     },
     /**
      * @param {String[]|String} inputLogs
@@ -55,8 +55,8 @@ export const logger = {
         const str = Array.isArray(inputLogs) ? inputLogs.join('\n') : inputLogs
         return str.replace(/\x1b\[.*?m/g, '')
     },
-    raw: [],
-    json: [],
+    raw: [] as string[],
+    json: [] as string[],
 }
 
 /**
@@ -76,27 +76,27 @@ export const C = {
     cyan: str => C.output(36, str),
     blue: str => C.output(34, str),
     primary: str => {
-        const primary: Color = configFn().terminal.theme.primary
+        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, 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, 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`,
     /** Output a line of title */
-    line(title = '', length = configFn().terminal.theme.pageWidth, clr = configFn().terminal.theme.primary, char = '=', paddingX = configFn().terminal.theme.paddingX) {
-        const padX = ' '.repeat(paddingX)
-        this.log('\u00A0\n' + padX + this.rgb(...clr) + (title + ' ').padEnd(length, char) + this.reset + padX + '\u00A0\n')
+    line(title = '', length = configFn()?.terminal?.theme?.pageWidth, clr = configFn()?.terminal?.theme?.primary, char = '=', paddingX = configFn()?.terminal?.theme?.paddingX) {
+        const padX = ' '.repeat(paddingX || 0)
+        this.log('\u00A0\n' + padX + this.rgb(...clr) + (title + ' ').padEnd(length || 0, char) + this.reset + padX + '\u00A0\n')
     },
     /** 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 = [], clr = configFn().terminal.theme.fontColor, paddingX = configFn().terminal.theme.paddingX) {
+    cols(strings, limits: number[] = [], clr = configFn()?.terminal?.theme?.fontColor, paddingX = configFn()?.terminal?.theme?.paddingX) {
 
         if (!limits.length) {
-            const colWidth = Math.round(configFn().terminal.theme.pageWidth / strings.length)
-            limits = Array(strings.length - 1).fill(2).map((itm, i) => colWidth * i + 1)
+            const colWidth = Math.round(configFn()?.terminal?.theme.pageWidth / strings.length)
+            limits = Array(strings.length - 1).fill(2).map((itm, i) => colWidth * i + 1) as number[]
         }
         const str = strings.reduce((glob, str = '', i) => {
             const realCharLength = str.toString().replace(/\x1b\[.*?m/, '').length
@@ -110,15 +110,15 @@ export const C = {
     log(...stringsCtxMayBeFirstParam) {
         stringsCtxMayBeFirstParam.forEach(str => this.logClr(str, undefined, undefined))
     },
-    logClr(str, clr = configFn().terminal.theme.fontColor, paddingX = configFn().terminal.theme.paddingX) {
+    logClr(str, clr = configFn()?.terminal?.theme?.fontColor, paddingX = configFn()?.terminal?.theme?.paddingX) {
         if (!isset(str)) return
-        const padX = ' '.repeat(paddingX)
-        str = padX + (isset(clr) ? this.rgb(...clr) : '') + str.toString().replace(/\n/g, '\n' + padX + (isset(clr) ? this.rgb(...clr) : ''))
+        const padX = ' '.repeat(paddingX || 0)
+        str = padX + (typeof clr !== 'undefined' ? this.rgb(...clr) : '') + str.toString().replace(/\n/g, '\n' + padX + (typeof clr !== 'undefined' ? this.rgb(...clr) : ''))
         logger.log(str + this.reset, 'info')
     },
     info(...str) {
         str.forEach((s, i) => {
-            if (i === 0) this.logClr('ⓘ  ' + s, configFn().terminal.theme.primary)
+            if (i === 0) this.logClr('ⓘ  ' + s, configFn()?.terminal?.theme?.primary)
             else this.log(this.dimStrSplit(s))
         })
         this.log(' ')
@@ -138,7 +138,7 @@ export const C = {
     applicationError: (color, ...str) => logErrPrivate('warn', color, ...str),
     warningLight: (color, ...str) => logErrPrivate('warn', [196, 120, 52], ...str),
     dimStrSplit(...logs) {
-        let logsStr = []
+        let logsStr: string[] = []
         logs.filter(isset).forEach(log => log.toString().split('\n').forEach(line => line && logsStr.push(this.dim(`    ${line}`))))
         return logsStr.join('\n')
     },
@@ -159,26 +159,26 @@ export const C = {
             }
         })
     },
-    notifications: [],
+    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 = configFn().terminal.theme.paddingY, paddingX = configFn().terminal.theme.paddingX) {
+    gradientize(str = '', rgb1 = configFn()?.terminal?.theme?.shade1, rgb2 = configFn()?.terminal?.theme?.shade2, bgRgb = configFn()?.terminal?.theme?.bgColor, paddingY = configFn()?.terminal?.theme?.paddingY, paddingX = configFn()?.terminal?.theme?.paddingX) {
 
         const lines = str.split('\n')
         const largestLine = lines.reduce((sum, line) => sum < line.length ? line.length : sum, 0)
         const rgbParts = rgb1.map((val, i) => (val - rgb2[i]) / (lines.length))
 
         const bg = bgRgb ? this.bg(bgRgb[0], bgRgb[1], bgRgb[2]) : ''
-        const padX = ' '.repeat(paddingX)
+        const padX = ' '.repeat(paddingX || 0)
         const padLine = bg + padX + ' '.padEnd(largestLine, ' ') + padX + '\x1b[0m\n'
 
-        console.log(padLine.repeat(paddingY) +
+        console.log(padLine.repeat(paddingY || 0) +
             lines.reduce((s, line, i) => {
-                return s + bg + padX + this.rgb(...rgb1.map((val, i2) => Math.round(val - i * rgbParts[i2]))) + line.padEnd(largestLine, ' ') + padX + '\x1b[0m\n'
+                return s + bg + padX + this.rgb(...((rgb1 as Color).map((val, i2) => Math.round(val - i * rgbParts[i2]))) as Color) + line.padEnd(largestLine, ' ') + padX + '\x1b[0m\n'
             }, '') +
-            padLine.repeat(paddingY))
+            padLine.repeat(paddingY || 0))
     },
     debugModeLog(title, ...string) {
-        this.logClr('🐞 ' + title, configFn().terminal.theme.debugModeColor, 0)
+        this.logClr('🐞 ' + title, configFn()?.terminal?.theme?.debugModeColor, 0)
         this.log(this.dimStrSplit(...string))
     },
     // DEPRECATED
@@ -216,7 +216,7 @@ function logErrPrivate(level: NotInfoLogLevel, color: Color, ...errors) {
 
     if (errors.length && errors[0]) {
         const messages = errors.map((e, i) => {
-            if (typeof e.log === 'function') {
+            if (typeof e?.log === 'function') {
                 e.log()
                 return ''
             } else return getStringFromErr(e, i)
@@ -286,7 +286,7 @@ function stringifyExtraInfos(extraInfoOriginal, type, color, level = 0) {
  * @param {String} char Default: '.'
  * @param {String} msg String before char. Final output will be `${str}${char.repeat(step)}`
  */
-export function cliProgressBar(step, char = '.', msg = `\x1b[2mⓘ Waiting response`) {
+export function cliProgressBar(step: number, char = '.', msg = `\x1b[2mⓘ Waiting response`) {
     if (isset(process) && isset(process.stdout) && isset(process.stdout.clearLine)) {
         process.stdout.clearLine(0)
         process.stdout.cursorTo(0)
@@ -304,9 +304,9 @@ export class cliLoadingSpinner {
     frameRate: number
     animFrames: string[]
     activeProcess: any
-    frameNb: number
-    progressMessage: string
-    interval: any
+    frameNb: number = 0
+    progressMessage: string = ''
+    interval: any = -1
 
     constructor(type = 'dots' as loadingSpinnerTypes, activeProcess = process) {
         const anims = {
@@ -349,6 +349,6 @@ export class cliLoadingSpinner {
 
 
 export function dim(str = '') {
-    return configFn().terminal.noColor ? str : `\x1b[2m${str.toString().split('\n').join('\x1b[0m\n\x1b[2m')}\x1b[0m`
+    return configFn()?.terminal?.noColor ? str : `\x1b[2m${str.toString().split('\n').join('\x1b[0m\n\x1b[2m')}\x1b[0m`
 }
 

package/src/loop-utils.ts

@@ -6,7 +6,7 @@ import { err500IfNotSet } from "./error-utils"
 import { isObject } from "./is-object"
 
 export function forI<T extends any[] | any>(nbIterations: number, callback: (number: number, previousValue, arrayOfPreviousValues: any[]) => T): T[] {
-    const results = []
+    const results: any[] = []
     for (let i = 0; i < nbIterations; i++) {
         const prevValue = results[results.length - 1]
         results.push(callback(i, prevValue, results))
@@ -15,7 +15,7 @@ export function forI<T extends any[] | any>(nbIterations: number, callback: (num
 }
 
 export async function forIasync<T extends any[] | any>(nbIterations: number, callback: (number) => T): Promise<T[]> {
-    const results = []
+    const results: any[] = []
     for (let i = 0; i < nbIterations; i++) {
         results.push(await callback(i))
     }
@@ -41,7 +41,7 @@ export type RecursiveConfig = { disableCircularDependencyRemoval?: boolean }
  * NOTE: will remove circular references
  * /!\ check return values
  */
-export async function recursiveGenericFunction(item: ObjectGeneric | any[], callback: RecursiveCallback, config: RecursiveConfig = {}, addr$ = '', lastElementKey: string | number = '', parent?, techFieldToAvoidCircularDependency = []) {
+export async function recursiveGenericFunction(item: ObjectGeneric | any[], callback: RecursiveCallback, config: RecursiveConfig = {}, addr$ = '', lastElementKey: string | number = '', parent?, techFieldToAvoidCircularDependency: any[] = []) {
     err500IfNotSet({ callback })
 
     if (!techFieldToAvoidCircularDependency.includes(item)) {
@@ -81,7 +81,7 @@ export async function recursiveGenericFunction(item: ObjectGeneric | any[], call
  * NOTE: will remove circular references
  * /!\ check return values
  */
-export function recursiveGenericFunctionSync(item: ObjectGeneric | any[], callback: RecursiveCallback, config: RecursiveConfig = {}, addr$ = '', lastElementKey: string | number = '', parent?, techFieldToAvoidCircularDependency = []) {
+export function recursiveGenericFunctionSync(item: ObjectGeneric | any[], callback: RecursiveCallback, config: RecursiveConfig = {}, addr$ = '', lastElementKey: string | number = '', parent?, techFieldToAvoidCircularDependency: any[] = []) {
     err500IfNotSet({ callback })
 
     if (!techFieldToAvoidCircularDependency.includes(item)) {

package/src/mongo-utils.ts

@@ -5,10 +5,11 @@ import { isType } from "./validation-utils"
 import { isset } from "./isset"
 
 /** @return undefined if cannot find _id */
-export function getId(obj: any = {}): string {
+export function getId(obj: any = {}): string | undefined {
     if (!obj) return // null case
     if (obj._id) return obj._id.toString()
     else if (isType(obj, 'objectId')) return obj.toString()
+    else return
 }
 
 /** Merge filter with correct handling of OR and AND 

package/src/object-utils.ts

@@ -76,7 +76,7 @@ export function findByAddressAll(obj, addr, returnAddresses = false) {
         .replace(/\.\*/g, '.[^.]+') // replace * by [^. (all but a point)]
         + '$')
 
-    const matchingItems = []
+    const matchingItems: any[] = []
 
     recursiveGenericFunctionSync(obj, (item, address) => {
         if (addrRegexp.test(address)) matchingItems.push(returnAddresses ? [address, item] : item)
@@ -122,6 +122,7 @@ export const objForceWritePath = forcePathInObject
  */
 export function objForceWriteIfNotSet<MainObj extends Record<string, any>>(obj: MainObj, addr: string, item): 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}) */
@@ -140,10 +141,10 @@ export function cloneObject<MainObj extends Record<string, any>>(o: MainObj): Ma
 /** Deep clone. WILL REMOVE circular references */
 export function deepClone<MainObj extends Record<string, any>>(obj: MainObj, cache = []): MainObj {
 
-    let copy
+    let copy: any | any[]
     // usefull to not modify 1st level objet by lower levels
     // this is required for the same object to be referenced not in a redundant way
-    const newCache = [...cache]
+    const newCache: any[] = [...cache]
     if (obj instanceof Date) return new Date(obj) as any
 
     // Handle Array
@@ -152,7 +153,7 @@ export function deepClone<MainObj extends Record<string, any>>(obj: MainObj, cac
         newCache.push(obj)
         copy = []
         for (var i = 0, len = obj.length; i < len; i++) {
-            copy[i] = deepClone(obj[i], newCache)
+            copy[i] = deepClone(obj[i], newCache as any)
         }
         return copy
     }
@@ -163,7 +164,7 @@ export function deepClone<MainObj extends Record<string, any>>(obj: MainObj, cac
         copy = {}
         for (var key in obj) {
             if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                copy[key] = deepClone(obj[key], newCache)
+                copy[key] = deepClone(obj[key], newCache as any)
             }
         }
         return copy
@@ -336,7 +337,7 @@ export function mergeDeepConfigurable(replacerForArrays = (prev, curr) => curr,
 export function flattenObject(data, config: { withoutArraySyntax?: boolean, withArraySyntaxMinified?: boolean } = {}) {
     const { withoutArraySyntax = false, withArraySyntaxMinified = false } = config
     const result = {}
-    const seenObjects = [] // avoidCircular reference to infinite loop
+    const seenObjects: any[] = [] // avoidCircular reference to infinite loop
     const recurse = (cur, prop) => {
         if (Array.isArray(cur)) {
             let l = cur.length

package/src/regexp-utils.ts

@@ -24,7 +24,7 @@ export function firstMatch(str: string, regExp: RegExp): string | undefined { re
 export function allMatches(str: string, reg: RegExp): string[] {
     let i = 0
     let matches
-    const arr = []
+    const arr: string[] = []
     if (typeof str !== 'string') C.error('Not a string provided as first argument for allMatches()')
     else {
         reg = new RegExp(reg, 'g')

package/src/string-utils.ts

@@ -96,8 +96,8 @@ export function getValuesBetweenStrings(str: string, openingOrSeparator, closing
 
     str = str.replace(/<</g, '§§"').replace(/>>/g, '"§§')
 
-    const arrayValues = []
-    const betweenArray = []
+    const arrayValues: string[] = []
+    const betweenArray: string[] = []
     let level = 0
     let ignoreUntil: boolean | string = false
     let actualValue = ''
@@ -170,7 +170,7 @@ export function convertAccentedCharacters(str, config: { removeNumbers?: boolean
 }
 
 
-let generatedTokens = [] // cache to avoid collision
+let generatedTokens: string[] = [] // cache to avoid collision
 let lastTs = new Date().getTime()
 /** minLength 8 if unique 
 * @param {Number} length default: 20
@@ -213,9 +213,9 @@ export function pathJoinSafe(...pathBits: string[]) {
 
 
 export type MiniTemplaterOptions = {
-    valueWhenNotSet?: string
-    regexp?: RegExp
-    valueWhenContentUndefined?: string
+    valueWhenNotSet: string
+    regexp: RegExp
+    valueWhenContentUndefined: string
 }
 /** Replace variables in a string like: `Hello {{userName}}!`
  * @param {String} content 
@@ -224,14 +224,14 @@ export type MiniTemplaterOptions = {
  * * valueWhenNotSet => replacer for undefined values. Default: ''
  * * regexp          => must be 'g' and first capturing group matching the value to replace. Default: /{{\s*([^}]*)\s*}}/g
  */
-export function miniTemplater(content: string, varz: ObjectGeneric, options: MiniTemplaterOptions = {}): string {
-    options = {
+export function miniTemplater(content: string, varz: ObjectGeneric, options: Partial<MiniTemplaterOptions> = {}): string {
+    const options2:MiniTemplaterOptions = {
         valueWhenNotSet: '',
         regexp: /{{\s*([^}]*)\s*}}/g,
         valueWhenContentUndefined: '',
         ...options,
     }
-    return isset(content) ? content.replace(options.regexp, (m, $1) => isset(varz[$1]) ? varz[$1] : options.valueWhenNotSet) : options.valueWhenContentUndefined
+    return isset(content) ? content.replace(options2.regexp, (m, $1) => isset(varz[$1]) ? varz[$1] : options2.valueWhenNotSet) : options2.valueWhenContentUndefined
 }
 
 

package/src/tests-utils.ts

@@ -35,7 +35,7 @@ export const restTestMini = {
     },
     nbSuccess: 0,
     nbError: 0,
-    lastErrors: []
+    lastErrors: [] as any[]
 }
 
 /** if validatorObject param is not set then it will consider checking that the value is set

package/src/timer-utils.ts

@@ -33,7 +33,7 @@ export async function waitUntilTrue(callback, timeoutSec = 10, errorAfterNSecond
 }
 
 
-const delayedLoopParams = []
+const delayedLoopParams: [any, number, any][] = []
 let isExecuting = false
 
 /** Allow to perform an action in a delayed loop, useful for example to avoid reaching limits on servers. This function can be securely called multiple times.
@@ -46,7 +46,7 @@ export async function executeInDelayedLoop(callback, time = 500, errorCallback =
     if (isExecuting) return
     isExecuting = true
     while (delayedLoopParams.length) {
-        const [callback, time, errorCallback] = delayedLoopParams.shift()
+        const [callback, time, errorCallback] = delayedLoopParams.shift() as any
         try {
             await callback()
             await timeout(time)

package/src/validation-utils.ts

@@ -90,7 +90,7 @@ export type ValidatorObject = {
 }
 export function validator(...paramsToValidate: ValidatorObject[]) {
     const errArray = validatorReturnErrArray(...paramsToValidate)
-    if (errArray.length) throw new DescriptiveError(...errArray)
+    if (errArray.length) throw new DescriptiveError(...(errArray as [string, object]))
 }
 
 
@@ -117,7 +117,7 @@ export function validatorReturnErrArray(...paramsToValidate: ValidatorObject[]):
 
         // parse => name: {myVar1: 'blah, myvar2: myvar2}
         if (typeof param.name === 'object' && !Array.isArray(param.name))
-            Object.keys(param.name).forEach(name => paramsFormatted.push(Object.assign({}, param, { name: name, value: param.name[name] })))
+            Object.keys(param.name).forEach(name => paramsFormatted.push(Object.assign({}, param, { name: name, value: param?.name?.[name] })))
         else paramsFormatted.push(param)
     })
 
@@ -131,28 +131,28 @@ export function validatorReturnErrArray(...paramsToValidate: ValidatorObject[]):
         const errMess = (msg, extraInfos = {}, errCode = 422): [string, object] => [msg, { code: errCode, origin: 'Generic validator', varName: name, gotValue: isset(value) && isset(value.data) && isset(value.data.data) ? { ...value, data: 'Buffer' } : value, ...extraInfos }]
 
         // accept syntax { 'myVar.var2': myVar.var2, ... }
-        if (!isset(name) && !hasValue) {
+        if (typeof name !== 'undefined' && !hasValue) {
             name = Object.keys(paramObj).find(param => !['name', 'value', 'type', 'eq', 'neq', 'in', 'lt', 'gt', 'lte', 'gte', 'length', 'minLength', 'maxLength', 'emptyAllowed', 'regexp', 'mustNotBeSet', 'isset', 'optional', 'isArray'].includes(param))
-            if (isset(name)) value = paramObj[name]
+            if (typeof name !== 'undefined') value = paramObj[name]
         }
         // if nameString ends by $ sign it is optional
-        if (isset(name) && /.*\$$/.test(name)) {
+        if (typeof name !== 'undefined' && /.*\$$/.test(name)) {
             name = name.substr(0, name.length - 1)
             optional = true
         }
 
         // DEFINED AND NOT EMPTY
-        if (!isset(value) && optional) continue
-        if (isset(value) && paramObj.mustNotBeSet) return errMess('variableMustNotBeSet')
+        if (typeof value === 'undefined' && optional) continue
+        if (typeof value !== 'undefined' && paramObj.mustNotBeSet) return errMess('variableMustNotBeSet')
         if (paramObj.mustNotBeSet) continue // exit
-        if (!isset(value)) return errMess('requiredVariableEmptyOrNotSet')
+        if (typeof value === 'undefined') return errMess('requiredVariableEmptyOrNotSet')
         if (!emptyAllowed && value === '') return errMess('requiredVariableEmpty')
 
         const isArray = paramObj.isArray
         if (isArray && !Array.isArray(value)) return errMess('wrongTypeForVar', { expectedType: 'array', gotType: typeof value })
 
         // TYPE
-        if (isset(paramObj.type)) {
+        if (typeof paramObj.type !== 'undefined') {
             const types = asArray(paramObj.type) // support for multiple type
             const areSomeTypeValid = types.some(type => {
                 if (type.endsWith('[]')) {
@@ -204,21 +204,21 @@ export function validatorReturnErrArray(...paramsToValidate: ValidatorObject[]):
                     any: () => true,
                 }
 
-                return isset(basicTypeCheck[type]) && basicTypeCheck[type](value) ||
+                return typeof basicTypeCheck?.[type] !== 'undefined' && basicTypeCheck?.[type](value) ||
                     typeof value === type && type !== 'object' || // for string, number, boolean...
-                    isset(configFn().customTypes[type]) && configFn().customTypes[type].test(value)
+                    typeof configFn()?.customTypes?.[type] !== 'undefined' && configFn()?.customTypes?.[type]?.test(value)
             })
             if (!areSomeTypeValid) return errMess(`wrongTypeForVar`, { expectedTypes: types.join(', '), gotType: Object.prototype.toString.call(value), gotValue: removeCircularJSONstringify(value).substring(0, 999) })
         }
 
         // GREATER / LESS
-        if (isset(paramObj.gte) && value < paramObj.gte) return errMess(`valueShouldBeSuperiorOrEqualForVar`, { shouldBeSupOrEqTo: paramObj.gte })
-        if (isset(paramObj.lte) && value > paramObj.lte) return errMess(`valueShouldBeInferiorOrEqualForVar`, { shouldBeInfOrEqTo: paramObj.lte })
-        if (isset(paramObj.gt) && value <= paramObj.gt) return errMess(`valueShouldBeSuperiorForVar`, { shouldBeSupOrEqTo: paramObj.gt })
-        if (isset(paramObj.lt) && value >= paramObj.lt) return errMess(`valueShouldBeInferiorForVar`, { shouldBeInfOrEqTo: paramObj.lt })
+        if (typeof paramObj.gte !== 'undefined' && value < paramObj.gte) return errMess(`valueShouldBeSuperiorOrEqualForVar`, { shouldBeSupOrEqTo: paramObj.gte })
+        if (typeof paramObj.lte !== 'undefined' && value > paramObj.lte) return errMess(`valueShouldBeInferiorOrEqualForVar`, { shouldBeInfOrEqTo: paramObj.lte })
+        if (typeof paramObj.gt !== 'undefined' && value <= paramObj.gt) return errMess(`valueShouldBeSuperiorForVar`, { shouldBeSupOrEqTo: paramObj.gt })
+        if (typeof paramObj.lt !== 'undefined' && value >= paramObj.lt) return errMess(`valueShouldBeInferiorForVar`, { shouldBeInfOrEqTo: paramObj.lt })
 
         // IN VALUES
-        if (isset(paramObj.in)) {
+        if (typeof paramObj.in !== 'undefined') {
             const equals = Array.isArray(paramObj.in) ? paramObj.in : [paramObj.in]
             if (!equals.some(equalVal => equalVal === value)) return errMess(`wrongValueForVar`, { supportedValues: JSON.stringify(equals) })
         }
@@ -236,19 +236,19 @@ export function validatorReturnErrArray(...paramsToValidate: ValidatorObject[]):
         }
 
         // INCLUDES
-        if (isset(paramObj.includes) && !value.includes(paramObj.includes))
+        if (typeof paramObj.includes !== 'undefined' && !value.includes(paramObj.includes))
             return errMess(`wrongValueForVar`, { shouldIncludes: paramObj.includes })
 
         // REGEXP
-        if (isset(paramObj.regexp) && !paramObj.regexp.test(value))
+        if (typeof paramObj.regexp !== 'undefined' && !paramObj.regexp.test(value))
             return errMess(`wrongValueForVar`, { shouldMatchRegexp: paramObj.regexp.toString() })
 
         // MIN / MAX LENGTH works for number length. Eg: 20180101.length == 8
-        if (isset(paramObj.minLength) && paramObj.minLength > (typeof value == 'number' ? value + '' : value).length)
+        if (typeof paramObj.minLength !== 'undefined' && paramObj.minLength > (typeof value == 'number' ? value + '' : value).length)
             return errMess(`wrongLengthForVar`, { minLength: paramObj.minLength })
-        if (isset(paramObj.maxLength) && paramObj.maxLength < (typeof value == 'number' ? value + '' : value).length)
+        if (typeof paramObj.maxLength !== 'undefined' && paramObj.maxLength < (typeof value == 'number' ? value + '' : value).length)
             return errMess(`wrongLengthForVar`, { maxLength: paramObj.maxLength })
-        if (isset(paramObj.length) && paramObj.length !== (typeof value == 'number' ? value + '' : value).length)
+        if (typeof paramObj.length !== 'undefined' && paramObj.length !== (typeof value == 'number' ? value + '' : value).length)
             return errMess(`wrongLengthForVar`, { length: paramObj.length })
     }
 

package/src/wtf-utils.ts

@@ -17,6 +17,8 @@ export function randomEmoji(msg, length = 20) {
     return o.padEnd(length, ' ') + (msg ? '< ' + msg : '')
 }
 
+type CompObject = { char: string, replacement: string }
+
 /** STRING COMPRESSOR
  * peut facilement être utilisé par uncomp directement (stock les metadonnées sur la comp)
  */
@@ -27,7 +29,7 @@ export function compAuto(str) {
 
 
     const unusedChars = utf8Chars.filter(c => !str.includes(c))
-    const charMap = []
+    const charMap: CompObject[] = []
 
     const mostFreqStr = str2 => {
         const o = {}
@@ -51,7 +53,7 @@ export function compAuto(str) {
         strLengthBefore = str.length
         const toReplace = mostFreqStr(str)
         if (isset(toReplace)) {
-            const char = unusedChars.shift()
+            const char: string = unusedChars.shift() as any
             charMap.push({ char, replacement: toReplace }) // { ù: 'aa' }
             str = str.replace(new RegExp(escapeRegexp(toReplace), 'g'), char)
         }
@@ -67,15 +69,15 @@ export function compAuto(str) {
 }
 
 export function unComp(str) {
-    const charMap = []
+    const charMap: CompObject[] = []
     const map = str.split('§')
     str = map.pop()
     map.forEach(e => {
-        let char = e[0]
+        const char: string = e[0]
         let replacement = e.substring(1, 999)
         if (replacement.includes('Ơ')) {
-            const [char, nb] = replacement.split('Ơ')
-            replacement = char.repeat(nb)
+            const [char, nb] = replacement.split('Ơ') as [string, string]
+            replacement = char.repeat(parseInt(nb))
         }
         charMap.push({ char, replacement })
     })

package/tsconfig.json

@@ -5,6 +5,7 @@
         "esModuleInterop": true,
         "allowSyntheticDefaultImports": true,
         "noImplicitAny": false,
+        "strict": true,
         "declaration": true,
         "moduleResolution": "node",
         "sourceMap": true,