topkat-utils 1.0.60 → 1.1.2

package/index.ts

@@ -0,0 +1,38 @@
+export * from './src/array-utils'
+export * from './src/date-utils'
+export * from './src/env-utils'
+export * from './src/error-utils'
+export * from './src/isset'
+export * from './src/logger-utils'
+export * from './src/loop-utils'
+export * from './src/math-utils'
+export * from './src/mongo-utils'
+export * from './src/object-utils'
+export * from './src/string-utils'
+export * from './src/wtf-utils'
+export * from './src/validation-utils'
+export * from './src/transaction-utils'
+export * from './src/timer-utils'
+export * from './src/is-empty'
+export * from './src/remove-circular-json-stringify'
+export * from './src/is-object'
+export { registerConfig } from './src/private/config'
+
+import { moyenne } from './src/math-utils'
+import { kebabCase, snakeCase } from './src/string-utils'
+import { shuffleArray, noDuplicateFilter } from './src/array-utils'
+import { issetOr, validator } from './src/validation-utils'
+import { objFilterUndefinedRecursive } from './src/object-utils'
+import { removeCircularJSONstringify } from './src/remove-circular-json-stringify'
+
+// ALIASES
+export const int = parseInt
+export const average = moyenne
+export const arrayUniqueValue = noDuplicateFilter
+export const JSONstringyParse = o => JSON.parse(removeCircularJSONstringify(o))
+export const removeUndefinedKeys = objFilterUndefinedRecursive
+export const randomizeArray = shuffleArray
+export const dashCase = kebabCase
+export const underscoreCase = snakeCase
+export const required = validator // alias for readability
+export const orIsset = issetOr

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "topkat-utils",
-  "version": "1.0.60",
+  "version": "1.1.2",
   "type": "commonjs",
   "private": false,
   "description": "UTILS BIG TIME",
   "author": "538ROMEO",
   "license": "ISC",
-  "main": "./utils.js",
+  "main": "dist/index.js",
   "scripts": {
     "build": "tsc",
     "bump:major": "npm run build & node node_modules/bump-simple/bump-simple.js --major",

package/src/array-utils.ts

@@ -0,0 +1,128 @@
+//----------------------------------------
+// ARRAY UTILS
+//----------------------------------------
+import { ensureObjectProp, objForceWriteIfNotSet } from "./object-utils"
+import { isset } from "./isset"
+
+export function shuffleArray(array) {
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [array[i], array[j]] = [array[j], array[i]]
+    }
+    return array
+}
+
+
+/**
+ * Maye sure obj[addr] is an array and push a value to it
+ * @param {Object} obj parent object
+ * @param {String} addr field name in parent
+ * @param {Any} valToPush
+ * @param {Boolean} onlyUniqueValues default:false; may be true or a comparision function; (a,b) => return true if they are the same like (a, b) => a.name === b.name
+ * @return obj[addr] eventually processed by the callback
+ */
+export function ensureIsArrayAndPush(obj: object, addr: string, valToPush, onlyUniqueValues: Function) {
+    return ensureObjectProp(obj, addr, [], objValue => {
+        if (isset(onlyUniqueValues)) {
+            let duplicateFound = false
+            if (typeof onlyUniqueValues === 'function') duplicateFound = objValue.some(a => onlyUniqueValues(a, valToPush))
+            else duplicateFound = objValue.includes(valToPush)
+            if (!duplicateFound) objValue.push(valToPush)
+        } else objValue.push(valToPush)
+    })
+}
+
+
+/** If a string is provided, return it as array else return the value */
+export function strAsArray(arrOrStr) {
+    return typeof arrOrStr === 'string' ? [arrOrStr] : arrOrStr
+}
+
+/** If not an array provided, return the array with the value
+ * /!\ NOTE /!\ In case the value is null or undefined, it will return that value
+ */
+export function asArray<T extends any[] | any>(item: T): T extends undefined ? undefined : T extends any[] ? T : T[] {
+    return ((typeof item === 'undefined' ? item : Array.isArray(item) ? item : [item]) as T extends undefined ? undefined : T extends any[] ? T : T[])
+}
+
+/** Array comparison
+ * @return {object} { inCommon, notInB, notInA }
+ */
+export function compareArrays(arrayA: any[], arrayB: any[], compare = (a, b) => a === b) {
+    return {
+        inCommon: getArrayInCommon(arrayA, arrayB, compare),
+        notInB: getNotInArrayA(arrayB, arrayA, compare),
+        notInA: getNotInArrayA(arrayA, arrayB, compare),
+    }
+}
+
+/**
+ * @return [] only elements that are both in arrayA and arrayB
+ */
+export function getArrayInCommon(arrayA = [], arrayB = [], compare = (a, b) => a === b): any[] {
+    if (!Array.isArray(arrayA) || !Array.isArray(arrayB)) return []
+    else return arrayA.filter(a => arrayB.some(b => compare(a, b)))
+}
+
+/**
+ * @return [] only elements that are in arrayB and not in arrayA
+ */
+export function getNotInArrayA(arrayA = [], arrayB = [], compare = (a, b) => a === b): any[] {
+    if (!Array.isArray(arrayA) && Array.isArray(arrayB)) return arrayB
+    else if (!Array.isArray(arrayB)) return []
+    else return arrayB.filter(b => !arrayA.some(a => compare(a, b)))
+}
+
+/**
+ * @return [] only elements that are in neither arrayA and arrayB
+ */
+export function getArrayDiff(arrayA = [], arrayB = [], compare = (a, b) => a === b): any[] {
+    return [...getNotInArrayA(arrayA, arrayB, compare), ...getNotInArrayA(arrayB, arrayA, compare)]
+}
+
+/** filter duplicate values in an array 
+ * @param {function} comparisonFn default:(a, b) => a === b. A function that shall return true if two values are considered equal
+ * @return {array|function}
+ */
+export function noDuplicateFilter(arr, comparisonFn = (a, b) => a === b): any[] {
+    return arr.filter((a, i, arr) => arr.findIndex(b => comparisonFn(a, b)) === i)
+}
+
+/** Count number of occurence of item in array */
+export function arrayCount(item: any, arr: any[]): number {
+    return arr.reduce((total, item2) => item === item2 ? total + 1 : total, 0)
+}
+
+/**
+ * Sort an array in an object of subArrays, no duplicate.
+ * @param {Array} array 
+ * @param {function} getFieldFromItem (itemOfArray) => field[String|Number]
+ * tell me how you want to sort your Array
+ */
+export function arrayToObjectSorted(array, getFieldFromItem) {
+    const res = {}
+
+    array.forEach(item => {
+        objForceWriteIfNotSet(res, getFieldFromItem(item), [])
+        res[getFieldFromItem(item)].push(item)
+    })
+
+    return res
+}
+
+/**
+ * @param {Function} comparisonFunction default: (itemToPush, itemAlreadyInArray) => itemToPush === itemAlreadyInArray; comparison function to consider the added item duplicate
+ */
+export function pushIfNotExist(arrayToPushInto, valueOrArrayOfValuesToBePushed, comparisonFunction = (a, b) => a === b): any[] {
+    const valuesToPush = asArray(valueOrArrayOfValuesToBePushed).filter(a => !arrayToPushInto.some(b => comparisonFunction(a, b)))
+    arrayToPushInto.push(...valuesToPush)
+    return arrayToPushInto
+}
+
+export function isNotEmptyArray(arr): boolean {
+    return Array.isArray(arr) && !!arr.length
+}
+
+export function randomItemInArray<T>(array: T[]): T {
+    return array[Math.floor(Math.random() * array.length)]
+}

package/src/date-utils.ts

@@ -0,0 +1,377 @@
+//----------------------------------------
+// DATE UTILS
+//----------------------------------------
+import { isset } from "./isset"
+import { pad } from "./math-utils"
+import { dataValidationUtilErrorHandler } from "./private/error-handler"
+import { err422IfNotSet } from "./error-utils"
+
+const int = parseInt
+
+export function getDateAsInt12(dateAllFormat?: Date | string | number, errIfNotValid?): string { return getDateAsInt(dateAllFormat, errIfNotValid, true) } // alias
+
+export function humanReadableTimestamp(dateAllFormat: any): number {
+    if (isset(dateAllFormat)) dateAllFormat = getDateAsObject(dateAllFormat)
+    return parseInt(getDateAsInt12(dateAllFormat) + pad((dateAllFormat || new Date()).getUTCSeconds()) + pad((dateAllFormat || new Date()).getUTCMilliseconds(), 3))
+}
+
+/** format for 6/8/2018 => 20180806
+ * @param dateAllFormat multiple format allowed 2012, 20120101, 201201011200, new Date(), "2019-12-08T16:19:10.341Z" and all string that new Date() can parse
+ */
+export function getDateAsInt(dateAllFormat: Date | string | number = new Date(), errIfNotValid$ = false, withHoursAndMinutes$ = false): string { // optional
+    let dateInt
+    if (typeof dateAllFormat === 'string' && dateAllFormat.includes('/')) {
+        // 01/01/2020 format
+        const [d, m, y] = dateAllFormat.split('/')
+        return y + m.toString().padStart(2, '0') + d.toString().padStart(2, '0')
+    } else if (isDateIntOrStringValid(dateAllFormat)) {
+        // we can pass an int or string format (20180106)
+        dateInt = (dateAllFormat + '00000000').substr(0, 12) // add default 000000 for "month days minutes:sec" if not set
+    } else {
+        let date: any = dateAllFormat
+        if (typeof date === 'string') date = new Date(date)
+        const realDate: Date = date
+        //let dateArr = dateAllFormat.toString().split(); // we cannot use ISOString
+        dateInt = '' + realDate.getUTCFullYear() + pad(realDate.getUTCMonth() + 1) + pad(realDate.getUTCDate()) + pad(realDate.getUTCHours()) + pad(realDate.getUTCMinutes())
+    }
+    isDateIntOrStringValid(dateInt, errIfNotValid$)
+    return (withHoursAndMinutes$ ? dateInt : dateInt.substr(0, 8))
+}
+
+
+export function getMonthAsInt(dateAllFormat: Date | string | number = new Date()): number {
+    let dateInt
+    if (isDateIntOrStringValid(dateAllFormat)) {
+        // we can pass an int or string format (20180106)
+        dateInt = (dateAllFormat + '').substr(0, 6)
+    } else {
+        let date: any = dateAllFormat
+        if (typeof date === 'string') date = new Date(date)
+        //let dateArr = dateAllFormat.toString().split(); // we cannot use ISOString
+        dateInt = '' + date.getUTCFullYear() + pad(date.getUTCMonth() + 1)
+    }
+    return int(dateInt)
+}
+/** 
+ * @param dateAllFormat multiple format allowed 2012, 20120101, 201201011200, new Date(), "2019-12-08T16:19:10.341Z" and all string that new Date() can parse
+ */
+export function getDateAsObject(dateAllFormat: any = new Date(), errIfNotValid$ = true): Date {
+    let dateObj = dateAllFormat
+    if (isDateIntOrStringValid(dateAllFormat)) {
+        const [y, M, d, h, m] = dateStringToArray(dateAllFormat)
+        dateObj = new Date(`${y}-${M}-${d}T${h}:${m}`)
+    } else if (typeof dateAllFormat === 'string') {
+        dateObj = new Date(dateAllFormat)
+    } else {
+        dateObj = new Date(dateAllFormat.getTime()) // clone
+    }
+    isDateIsoOrObjectValid(dateObj, errIfNotValid$)
+    return dateObj
+}
+
+/** [2018,01,06] */
+export function dateStringToArray(strOrInt) {
+    err422IfNotSet({ strOrInt })
+
+    const dateStr = strOrInt.toString()
+    return [
+        dateStr.substr(0, 4), // Y
+        dateStr.substr(4, 2) || '01', // M
+        dateStr.substr(6, 2) || '01', // D
+        dateStr.substr(8, 2) || '12', // H 12 default to avoid time shift when converting to dateObj
+        dateStr.substr(10, 2) || '00', // M
+        dateStr.substr(12, 2) || '00', // S
+        dateStr.substr(14, 3) || '000', // MS
+    ]
+}
+
+/**
+ * @param dateAllFormat default: actualDate
+ * @returns ['01', '01', '2019'] OR **string** if separator is provided */
+export function dateArray(dateAllFormat: Date | string | number = getDateAsInt()): [string, string, string] {
+    const dateStr = getDateAsInt(dateAllFormat).toString()
+    return [
+        dateStr.substr(6, 2), // D
+        dateStr.substr(4, 2), // M
+        dateStr.substr(0, 4), // Y
+    ]
+}
+
+/**
+ * @param dateAllFormat default: actualDate
+ * @returns ['01', '01', '2019'] OR **string** if separator is provided */
+export function dateArrayInt(dateAllFormat: Date | string | number = getDateAsInt()): [number, number, number] {
+    const dateStr = getDateAsInt(dateAllFormat).toString()
+    return [
+        int(dateStr.substr(6, 2)), // D
+        int(dateStr.substr(4, 2)), // M
+        int(dateStr.substr(0, 4)), // Y
+    ]
+}
+
+
+/**
+ * @return 01/01/2012 (alias of dateArrayFormatted(date, '/'))
+ */
+export function dateFormatted(dateAllFormat: Date | string | number, separator = '/') { return dateArray(dateAllFormat).join(separator) }
+
+/** Date with custom offset (Ex: +2 for France) */
+export function dateOffset(offsetHours, dateObj = new Date()) {
+
+    var utc = Date.UTC(dateObj.getUTCFullYear(), dateObj.getUTCMonth(), dateObj.getUTCDate(),
+        dateObj.getUTCHours(), dateObj.getUTCMinutes(), dateObj.getUTCSeconds())
+
+    return new Date(utc + (3600000 * offsetHours))
+}
+
+//----------------------------------------
+// TIME UTILS
+//----------------------------------------
+
+/**  */
+export function getTimeAsInt(timeOrDateInt: any = getDateAsInt12()) {
+    if (isDateIntOrStringValid(timeOrDateInt)) {
+        const tl = timeOrDateInt.toString().length
+        return int(timeOrDateInt.toString().substring(tl - 4, tl))
+    } else if (typeof timeOrDateInt === 'string' && timeOrDateInt.length === 5 && timeOrDateInt.includes(':'))
+        return int(timeOrDateInt.replace(':', ''))
+    else return 'dateInvalid'
+}
+
+/**
+ * @param {timeInt|dateInt12} Eg: 2222 OR 201201012222. Default, actual dateInt12
+ * @param {String} separator default: ":"
+ */
+export function getIntAsTime(intOrDateTimeInt = getDateAsInt12(), separator = ':') {
+    const time = intOrDateTimeInt.toString().padStart(4, '0')
+    const tl = time.length
+    return time.substring(tl - 4, tl - 2) + separator + time.substring(tl - 2, tl)
+}
+
+export function isTimeStringValid(timeStr, outputAnError$ = false) {
+    let timeArr = timeStr.split(':')
+    let h = int(timeArr[0])
+    let m = int(timeArr[1])
+    let test1 = h >= 0 && h < 24
+    let test2 = m >= 0 && m < 60
+    if (outputAnError$ && !(test1 && test2)) throw new dataValidationUtilErrorHandler('timeStringOutOfRange', 422, { origin: 'Time validator' })
+    else return test1 && test2
+}
+
+//----------------------------------------
+// DURATIONS
+//----------------------------------------
+
+export function getDuration(startDate, endDate, inMinutes = false) {
+    const startDateO = getDateAsObject(startDate)
+    const endDateO = getDateAsObject(endDate)
+    let diffInSec = Math.floor(endDateO.getTime() / 1000) - Math.floor(startDateO.getTime() / 1000)
+
+    if (inMinutes) return Math.floor(diffInSec / 60)
+    else return [
+        Math.floor(diffInSec / (24 * 3600)), // D
+        Math.floor((diffInSec % (24 * 3600)) / 3600), // H
+        Math.floor(((diffInSec % (24 * 3600)) % 3600) / 60), // M
+    ]
+}
+
+/** compare two object with DATE INT, if they overlap return true 
+ * @param {Object} event1 {startDate, endDate} 
+ * @param {Object} event2 {startDate, endDate}
+ * @param {String} fieldNameForStartDate$ replace startDate with this string
+ * @param {String} fieldNameForEndDate$ replace endDate with this string
+ * @param {Boolean} allowNull$ if false, retrun false if any of the startdates or enddates are not set
+ * @param {Boolean} strict$ if true, 
+ */
+export function doDateOverlap(event1, event2, fieldNameForStartDate$ = 'startDate', fieldNameForEndDate$ = 'endDate', allowNull$ = true, strict$ = false) {
+    if (!allowNull$ && !isset(event1[fieldNameForStartDate$], event1[fieldNameForEndDate$], event2[fieldNameForStartDate$], event2[fieldNameForEndDate$])) return false
+
+    if (strict$)
+        return (!event2[fieldNameForEndDate$] || event1[fieldNameForStartDate$] < event2[fieldNameForEndDate$]) && (!event1[fieldNameForEndDate$] || event1[fieldNameForEndDate$] > event2[fieldNameForStartDate$])
+
+    return (!event2[fieldNameForEndDate$] || event1[fieldNameForStartDate$] <= event2[fieldNameForEndDate$]) && (!event1[fieldNameForEndDate$] || event1[fieldNameForEndDate$] >= event2[fieldNameForStartDate$])
+}
+
+type DateAllFormat = DateObjectFormat | DateStringFormats
+type DateStringFormats = 'dateInt8' | 'dateInt12' | 'humanReadableTimestamp'
+type DateObjectFormat = 'date'
+
+export function nextWeekDay(fromDate, weekDayInt?: 0 | 1 | 2 | 3 | 4 | 5 | 6, outputFormat?: DateStringFormats, sameDayAllowed?: boolean): number
+export function nextWeekDay(fromDate, weekDayInt?: 0 | 1 | 2 | 3 | 4 | 5 | 6, outputFormat?: DateObjectFormat, sameDayAllowed?: boolean): Date
+export function nextWeekDay(fromDate, weekDayInt?: 0 | 1 | 2 | 3 | 4 | 5 | 6, outputFormat = 'date', sameDayAllowed = false): any {
+    const date = getDateAsObject(fromDate)
+    if (!isset(weekDayInt)) weekDayInt = (date.getDay() as 0 | 1 | 2 | 3 | 4 | 5 | 6)
+    const toAdd = !sameDayAllowed && date.getDay() === weekDayInt ? 7 : 0
+    date.setUTCDate(date.getUTCDate() + toAdd + (7 + weekDayInt - date.getUTCDay()) % 7)
+    return getDateAs(date, outputFormat as any)
+}
+
+/**
+ * @param {String} outputFormat dateInt, dateInt8, dateInt12, date, humanReadableTimestamp, int (dateInt8)
+ */
+export function addDays(dateAllFormat?: Date | string | number, numberOfDays?: number, outputFormat?: 'dateInt8' | 'dateInt12' | 'humanReadableTimestamp'): string
+export function addDays(dateAllFormat?: Date | string | number, numberOfDays?: number, outputFormat?: 'date'): Date
+export function addDays(dateAllFormat: Date | string | number = getDateAsInt(), numberOfDays = 1, outputFormat: DateAllFormat = 'date'): any {
+    let date = getDateAsObject(dateAllFormat)
+    date.setTime(date.getTime() + numberOfDays * 24 * 60 * 60 * 1000)
+    return getDateAs(date, outputFormat as any)
+}
+
+/**
+ * @param {String} outputFormat dateInt, dateInt8, dateInt12, date, humanReadableTimestamp, int (dateInt8)
+ */
+export function addMinutes(dateAllFormat?: Date | string | number, numberOfMinutes?: number, outputFormat?: DateStringFormats): string
+export function addMinutes(dateAllFormat?: Date | string | number, numberOfMinutes?: number, outputFormat?: DateObjectFormat): Date
+export function addMinutes(dateAllFormat: Date | string | number = getDateAsInt(), numberOfMinutes = 1, outputFormat: DateAllFormat = 'date'): any {
+    let date = getDateAsObject(dateAllFormat)
+    date.setTime(date.getTime() + 1 * numberOfMinutes * 60 * 1000)
+    return getDateAs(date, outputFormat as any)
+}
+/**
+ * @param {String} outputFormat dateInt, dateInt8, dateInt12, date, humanReadableTimestamp, int (dateInt8)
+ */
+export function addHours(dateAllFormat?: Date | string | number, numberOfHours?: number, outputFormat?: 'dateInt8' | 'dateInt12' | 'humanReadableTimestamp'): string
+export function addHours(dateAllFormat?: Date | string | number, numberOfHours?: number, outputFormat?: 'date'): Date
+export function addHours(dateAllFormat: Date | string | number = getDateAsInt(), numberOfHours = 1, outputFormat: DateAllFormat = 'date'): any {
+    let date = getDateAsObject(dateAllFormat)
+    date.setTime(date.getTime() + 1 * numberOfHours * 60 * 60 * 1000)
+    return getDateAs(date, outputFormat as any)
+}
+/**
+ * @param {String} outputFormat dateInt, dateInt8, dateInt12, date, humanReadableTimestamp, int (dateInt8)
+ */
+export function addMonths(dateAllFormat?: Date | string | number, numberOfMonths?: number, outputFormat?: 'dateInt8' | 'dateInt12' | 'humanReadableTimestamp'): string
+export function addMonths(dateAllFormat?: Date | string | number, numberOfMonths?: number, outputFormat?: 'date'): Date
+export function addMonths(dateAllFormat: Date | string | number = getDateAsInt(), numberOfMonths = 1, outputFormat: DateAllFormat = 'date'): any {
+    let date = getDateAsObject(dateAllFormat)
+    date.setUTCMonth(date.getUTCMonth() + numberOfMonths)
+    return getDateAs(date, outputFormat as any)
+}
+/**
+ * @param {String} outputFormat dateInt, dateInt8, dateInt12, date, humanReadableTimestamp, int (dateInt8)
+ */
+export function addYears(dateAllFormat: Date | string | number = getDateAsInt(), numberOfYears = 1, outputFormat: DateAllFormat = 'date') {
+    let date = getDateAsObject(dateAllFormat)
+    date.setUTCFullYear(date.getUTCFullYear() + numberOfYears)
+    return getDateAs(date, outputFormat as any)
+}
+
+export function getDayOfMonth(dateAllFormat: Date | string | number = getDateAsInt()) {
+    let dateAsInt = getDateAsInt(dateAllFormat)
+    const [, , d] = dateStringToArray(dateAsInt)
+    return d
+}
+
+export function getYear(dateAllFormat: Date | string | number = getDateAsInt()) {
+    let dateAsInt = getDateAsInt(dateAllFormat)
+    const [y] = dateStringToArray(dateAsInt)
+    return y
+}
+
+
+export function getHours(dateAllFormat: Date | string | number = getDateAsInt()) {
+    let dateAsInt = getDateAsInt(dateAllFormat)
+    const [, , , h,] = dateStringToArray(dateAsInt)
+    return h
+}
+
+export function getMinutes(dateAllFormat: Date | string | number = getDateAsInt()) {
+    let dateAsInt = getDateAsInt(dateAllFormat)
+    const [, , , , m] = dateStringToArray(dateAsInt)
+    return m
+}
+
+/**
+ * @param {String} outputFormat dateInt, dateInt8, dateInt12, date, humanReadableTimestamp, int (dateInt8)
+ */
+export function lastDayOfMonth(dateAllFormat: Date | string | number = getDateAsInt(), outputFormat: DateAllFormat = 'date') {
+    let date = getDateAsObject(dateAllFormat)
+    const lastDay = new Date(date.getUTCFullYear(), date.getUTCMonth() + 1, 0)
+    lastDay.setUTCHours(date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds())
+    return getDateAs(lastDay, outputFormat as any)
+}
+
+/**
+ * @param {String} outputFormat dateInt, dateInt8, dateInt12, date, humanReadableTimestamp, int (dateInt8)
+ */
+export function firstDayOfMonth(dateAllFormat: Date | string | number = getDateAsInt(), outputFormat: DateAllFormat = 'date') {
+    let date = getDateAsObject(dateAllFormat)
+    const firstDay = new Date(date.getUTCFullYear(), date.getUTCMonth(), 1)
+    firstDay.setUTCHours(date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds())
+    return getDateAs(firstDay, outputFormat as any)
+}
+
+export function differenceInMilliseconds(startDateAllFormat, endDateAllFormat) {
+    const startDate = getDateAsObject(startDateAllFormat)
+    const endDate = getDateAsObject(endDateAllFormat)
+    return endDate.getTime() - startDate.getTime()
+}
+
+export function differenceInSeconds(startDateAllFormat, endDateAllFormat) {
+    return differenceInMilliseconds(startDateAllFormat, endDateAllFormat) / 1000
+}
+
+export function differenceInMinutes(startDateAllFormat, endDateAllFormat) {
+    return differenceInSeconds(startDateAllFormat, endDateAllFormat) / 60
+}
+
+export function differenceInHours(startDateAllFormat, endDateAllFormat) {
+    return differenceInMinutes(startDateAllFormat, endDateAllFormat) / 60
+}
+
+export function differenceInDays(startDateAllFormat, endDateAllFormat) {
+    return differenceInHours(startDateAllFormat, endDateAllFormat) / 24
+}
+
+export function differenceInWeeks(startDateAllFormat, endDateAllFormat) {
+    return differenceInDays(startDateAllFormat, endDateAllFormat) / 7
+}
+
+/**
+ * @param {String} outputDateFormat dateInt, dateInt8, dateInt12, date, humanReadableTimestamp, int (dateInt8)
+ */
+export function getDateAs(dateAllFormat?: Date | string | number, outputFormat?: 'dateInt8' | 'dateInt12' | 'humanReadableTimestamp'): string
+export function getDateAs(dateAllFormat?: Date | string | number, outputFormat?: 'date'): Date
+export function getDateAs(dateAllFormat: Date | string | number = new Date(), outputDateFormat: DateAllFormat = 'date') {
+    switch (outputDateFormat) {
+        case 'dateInt8':
+            return getDateAsInt(dateAllFormat)
+        case 'dateInt12':
+            return getDateAsInt12(dateAllFormat)
+        case 'humanReadableTimestamp':
+            return humanReadableTimestamp(dateAllFormat)
+        case 'date':
+        default:
+            return getDateAsObject(dateAllFormat)
+    }
+}
+
+
+export function isDateIntOrStringValid(dateStringOrInt, outputAnError = false, length?): boolean {
+    if (!isset(dateStringOrInt)) return false
+    const dateStr = dateStringOrInt.toString()
+
+    if (length && dateStr.length !== length) throw new dataValidationUtilErrorHandler(`wrongLengthForDateInt`, 422, { origin: 'Date Int validator', dateStringOrInt: dateStringOrInt, extraInfo: `${dateStringOrInt} length !== ${length}` })
+
+    if ((typeof dateStringOrInt === 'object' && isNaN(int(dateStr))) || ![4, 6, 8, 10, 12, 17].includes(dateStr.length)) return false
+
+    const dateArr = dateStringToArray(dateStringOrInt)
+    const [y, M, d, h, m] = dateArr
+
+    const test1 = dateArr.length >= 3 && int(y) >= 1000 // Y
+    const test2 = int(M) <= 12 && int(M) > 0 // M
+    const test3 = !isset(d) || int(d) <= 31 && int(d) > 0 // D
+    const test4 = !isset(h) || (int(h) <= 23 && int(h) >= 0) // H
+    const test5 = !isset(m) || (int(m) <= 59 && int(m) >= 0) // M
+
+    if (outputAnError && !(test1 && test2 && test3 && test4 && test5)) throw new dataValidationUtilErrorHandler(`dateStringOrIntFormatInvalid`, 422, { origin: 'Date Int validator', dateStringOrInt: dateStringOrInt, extraInfo: 'Needs YYYYMMDD[HHMM] between 100001010000 and 999912312359', dateArr, isYearValid: test1, isMonthValid: test2, isDayValid: test3, isHourValid: test4, isMinutesValid: test5 })
+    return true
+}
+
+export function isDateIsoOrObjectValid(dateIsoOrObj, outputAnError = false) {
+    let dateObj: Date | number | string = dateIsoOrObj
+    if (typeof dateIsoOrObj === 'string') dateObj = new Date(dateIsoOrObj)
+    let valid = dateObj instanceof Date
+    if (outputAnError && !valid) throw new dataValidationUtilErrorHandler('dateIsoStringOrObjectIsNotValid', 422, { origin: 'Date Object validator', isoDate: dateIsoOrObj })
+    return valid
+}

package/src/env-utils.ts

@@ -0,0 +1,29 @@
+//----------------------------------------
+// ENV UTILS
+//----------------------------------------
+
+/** Parse one dimention object undefined, true, false, null represented as string will be converted to primitives */
+export function parseEnv(env) {
+    const newEnv = {}
+    for (const k in env) {
+        const val = env[k]
+        if (val === 'undefined') newEnv[k] = undefined
+        else if (val === 'true') newEnv[k] = true
+        else if (val === 'false') newEnv[k] = false
+        else if (val === 'null') newEnv[k] = null
+        else newEnv[k] = env[k]
+    }
+    return newEnv
+}
+
+/** READ ONLY, output a parsed version of process.env
+ * use it like ENV().myVar
+ */
+export function ENV(): { [key: string]: any } {
+    const throwErr = () => { throw new Error('Please use process.env to write to env') }
+    return new Proxy(parseEnv(process.env), {
+        set: throwErr,
+        defineProperty: throwErr,
+        deleteProperty: throwErr,
+    })
+}

package/src/error-utils.ts

@@ -0,0 +1,77 @@
+//----------------------------------------
+// ERROR UTILS
+//----------------------------------------
+import { dataValidationUtilErrorHandler } from "./private/error-handler"
+import { isset } from "./isset"
+import { isEmpty } from "./is-empty"
+
+export function errIfNotSet(objOfVarNamesWithValues, additionalMessage) { return errXXXIfNotSet(422, false, objOfVarNamesWithValues) }
+
+export function err500IfNotSet(objOfVarNamesWithValues) { return errXXXIfNotSet(500, false, objOfVarNamesWithValues) }
+
+export function errIfEmptyOrNotSet(objOfVarNamesWithValues) { return errXXXIfNotSet(422, true, objOfVarNamesWithValues) }
+
+export function err500IfEmptyOrNotSet(objOfVarNamesWithValues) { return errXXXIfNotSet(500, true, objOfVarNamesWithValues) }
+
+export function errXXXIfNotSet(errCode, checkEmpty, objOfVarNamesWithValues) {
+    let missingVars = []
+    for (let prop in objOfVarNamesWithValues) {
+        if (!isset(objOfVarNamesWithValues[prop]) || (checkEmpty && isEmpty(objOfVarNamesWithValues[prop]))) missingVars.push(prop)
+    }
+    if (missingVars.length) throw new dataValidationUtilErrorHandler(`requiredVariableEmptyOrNotSet`, errCode, { origin: 'Validator', varNames: missingVars.join(', ') })
+}
+
+
+export function err422IfNotSet(o) {
+    let m = []
+    for (let p in o) if (!isset(o[p])) m.push(p)
+    if (m.length) throw new dataValidationUtilErrorHandler(`requiredVariableEmptyOrNotSet`, 422, { origin: 'Validator', varNames: m.join(', ') })
+}
+
+export function cleanStackTrace(stack) {
+    if (typeof stack !== 'string') return ''
+    stack.replace(/home\/[^/]+\/[^/]+\//g, '')
+    const lines = stack.split('\n')
+    const removeIfContain = [
+        'logger-utils.js',
+        'TCP.onread',
+        'readableAddChunk',
+        'Socket.EventEmitter.emit (domain.js',
+        'Socket.emit (events.js',
+        'Connection.EventEmitter.emit (domain.js',
+        'Connection.emit (events.js',
+        'Socket.Readable.push (_stream_readable',
+        'model.Query',
+        'Object.promiseOrCallback',
+        'Connection.<anonymous>',
+        'process.topLevelDomainCallback',
+        // internal
+        'internal/process',
+        'internal/timers',
+        'internal/modules',
+        'internal/main',
+        'DefaultError.throw',
+        'Object.throw',
+        'mongoose/lib/utils',
+        'at Array.forEach (<anonymous>)',
+    ]
+    const linesClean = lines
+        .filter(l => !removeIfContain.some(text => l.includes(text)))
+        .map((line, i) => {
+            if (i === 0) return ''
+            else {
+                const [, start, fileName, end] = line.match(/(^.+\/)([^/]+:\d+:\d+)(.{0,3})/) || []
+                return fileName ? `\x1b[2m${start}\x1b[0m${fileName}\x1b[2m${end}\x1b[0m` : `\x1b[2m${line}\x1b[0m`
+            }
+        })
+        .join('\n')
+    return linesClean
+}
+
+export async function tryCatch(callback: Function, onErr: Function = () => { }) {
+    try {
+        return await callback()
+    } catch (err) {
+        return await onErr(err)
+    }
+}

package/src/is-empty.ts

@@ -0,0 +1,5 @@
+export function isEmpty(objOrArr: object | any[] | string | null | undefined) {
+    if (Array.isArray(objOrArr) || typeof objOrArr === 'string') return objOrArr.length === 0
+    else if (typeof objOrArr == 'object' && objOrArr !== null && !(objOrArr instanceof Date)) return Object.keys(objOrArr).length === 0
+    else false
+}

package/src/is-object.ts

@@ -0,0 +1,3 @@
+
+/** test if object but not array and not null (null is an object in Js) */
+export function isObject(o: any): boolean { return o instanceof Object && [Object, Error].includes(o.constructor) }