@beecode/msh-util 1.2.1 → 2.0.0

package/dist/single-threshold-promise.d.ts

@@ -0,0 +1,31 @@
+export type AnyFunctionPromiseNoParams<T> = () => Promise<T>;
+/**
+ * SingleThresholdPromise returns a single promise, and subsequent calls made before the promise resolves will return the same promise.
+ * @example
+ * export const refreshTokenSingleThreshold = new SingleThresholdPromise(async () => {
+ *   const oldRefreshToken = await refreshTokenService.get()
+ *   const { accessToken, refreshToken } = await authService.refreshToken({
+ *     refreshToken: oldRefreshToken,
+ *   })
+ *   return { accessToken, refreshToken }
+ * })
+ *
+ * export const authService = {
+ *   refreshToken: async (): Promise<{ accessToken: string; refreshToken:string }> => {
+ *     return refreshTokenSingleThreshold.promise()
+ *   }
+ * }
+ */
+export declare class SingleThresholdPromise<T> {
+    protected _cache: {
+        promises?: {
+            resolve: (value: T | PromiseLike<T>) => void;
+            reject: (reason?: any) => void;
+        }[];
+    };
+    protected _factoryFn: AnyFunctionPromiseNoParams<T>;
+    constructor(factoryFn: AnyFunctionPromiseNoParams<T>);
+    protected _rejectPromises(): void;
+    promise(): Promise<T>;
+}
+//# sourceMappingURL=single-threshold-promise.d.ts.map

package/dist/single-threshold-promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-threshold-promise.d.ts","sourceRoot":"","sources":["../src/single-threshold-promise.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,CAAA;AAE5D;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,sBAAsB,CAAC,CAAC;IACpC,SAAS,CAAC,MAAM,EAAE;QAEjB,QAAQ,CAAC,EAAE;YAAE,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;YAAC,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,IAAI,CAAA;SAAE,EAAE,CAAA;KAC7F,CAAK;IAEN,SAAS,CAAC,UAAU,EAAE,0BAA0B,CAAC,CAAC,CAAC,CAAA;gBAEvC,SAAS,EAAE,0BAA0B,CAAC,CAAC,CAAC;IAIpD,SAAS,CAAC,eAAe,IAAI,IAAI;IAO3B,OAAO,IAAI,OAAO,CAAC,CAAC,CAAC;CAkB3B"}

package/dist/single-threshold-promise.js

@@ -0,0 +1,46 @@
+/**
+ * SingleThresholdPromise returns a single promise, and subsequent calls made before the promise resolves will return the same promise.
+ * @example
+ * export const refreshTokenSingleThreshold = new SingleThresholdPromise(async () => {
+ *   const oldRefreshToken = await refreshTokenService.get()
+ *   const { accessToken, refreshToken } = await authService.refreshToken({
+ *     refreshToken: oldRefreshToken,
+ *   })
+ *   return { accessToken, refreshToken }
+ * })
+ *
+ * export const authService = {
+ *   refreshToken: async (): Promise<{ accessToken: string; refreshToken:string }> => {
+ *     return refreshTokenSingleThreshold.promise()
+ *   }
+ * }
+ */
+export class SingleThresholdPromise {
+    _cache = {};
+    _factoryFn;
+    constructor(factoryFn) {
+        this._factoryFn = factoryFn;
+    }
+    _rejectPromises() {
+        if (this._cache.promises) {
+            this._cache.promises.forEach((promise) => promise.reject(new Error('Cache was cleaned')));
+        }
+        delete this._cache.promises;
+    }
+    async promise() {
+        if ('promises' in this._cache) {
+            return new Promise((resolve, reject) => {
+                this._cache.promises.push({ reject, resolve });
+            });
+        }
+        this._cache.promises = [];
+        const result = await this._factoryFn().catch((err) => {
+            this._rejectPromises();
+            throw err;
+        });
+        this._cache.promises.forEach((promise) => promise.resolve(result));
+        delete this._cache.promises;
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/singleton/async.d.ts

@@ -0,0 +1,50 @@
+export type AnyFunctionPromiseNoParams<T> = () => Promise<T>;
+/**
+ * This is a singleton wrapper that is used to wrap around async function. We have additional functionality to clear the cache
+ * and reject any subscriptions to initial promise. And we can also check if there is anything i cache
+ * @example
+ * export const configSingleton = new SingletonAsync(async () => {
+ *   await timeout(3000)
+ *   return {
+ *     env: process.env.NODE_ENV
+ *   } as const
+ * })
+ *
+ * // using
+ * // cache value before we call promise
+ * console.log(configSingleton().cache()) // undefined
+ * console.log('NODE_ENV: ', await configSingleton().promise().env) // NODE_ENV: prod
+ * // cache value after we call promise
+ * console.log(configSingleton().cache()) // { env: 'prod' }
+ */
+export declare class SingletonAsync<T> {
+    protected _cache: {
+        singleton?: T;
+        promises?: {
+            resolve: (value: T | PromiseLike<T>) => void;
+            reject: (reason?: any) => void;
+        }[];
+    };
+    protected _factory: AnyFunctionPromiseNoParams<T>;
+    constructor(factory: AnyFunctionPromiseNoParams<T>);
+    /**
+     * Empty cached value and reject any subscribed promise that is waiting for the initial promise to be resolved.
+     */
+    cleanCache(): void;
+    protected _rejectPromises(params: {
+        error: Error;
+    }): void;
+    /**
+     * Return singleton value in a promise. If there is no cached value then try to get it from factory.
+     * @template T
+     * @returns {Promise<T>}
+     */
+    promise(): Promise<T>;
+    /**
+     * Return cached value, if there is no value cached return undefined.
+     * @template T
+     * @returns {T | undefined}
+     */
+    cached(): T | undefined;
+}
+//# sourceMappingURL=async.d.ts.map

package/dist/singleton/async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../../src/singleton/async.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,CAAA;AAE5D;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,cAAc,CAAC,CAAC;IAC5B,SAAS,CAAC,MAAM,EAAE;QACjB,SAAS,CAAC,EAAE,CAAC,CAAA;QAEb,QAAQ,CAAC,EAAE;YAAE,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;YAAC,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,IAAI,CAAA;SAAE,EAAE,CAAA;KAC7F,CAAK;IAEN,SAAS,CAAC,QAAQ,EAAE,0BAA0B,CAAC,CAAC,CAAC,CAAA;gBAErC,OAAO,EAAE,0BAA0B,CAAC,CAAC,CAAC;IAIlD;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB,SAAS,CAAC,eAAe,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE,GAAG,IAAI;IASzD;;;;OAIG;IACG,OAAO,IAAI,OAAO,CAAC,CAAC,CAAC;IAuB3B;;;;OAIG;IACH,MAAM,IAAI,CAAC,GAAG,SAAS;CAOvB"}

package/dist/singleton/async.js

@@ -0,0 +1,75 @@
+/**
+ * This is a singleton wrapper that is used to wrap around async function. We have additional functionality to clear the cache
+ * and reject any subscriptions to initial promise. And we can also check if there is anything i cache
+ * @example
+ * export const configSingleton = new SingletonAsync(async () => {
+ *   await timeout(3000)
+ *   return {
+ *     env: process.env.NODE_ENV
+ *   } as const
+ * })
+ *
+ * // using
+ * // cache value before we call promise
+ * console.log(configSingleton().cache()) // undefined
+ * console.log('NODE_ENV: ', await configSingleton().promise().env) // NODE_ENV: prod
+ * // cache value after we call promise
+ * console.log(configSingleton().cache()) // { env: 'prod' }
+ */
+export class SingletonAsync {
+    _cache = {};
+    _factory;
+    constructor(factory) {
+        this._factory = factory;
+    }
+    /**
+     * Empty cached value and reject any subscribed promise that is waiting for the initial promise to be resolved.
+     */
+    cleanCache() {
+        delete this._cache.singleton;
+        this._rejectPromises({ error: new Error('Cache was cleaned') });
+    }
+    _rejectPromises(params) {
+        const { error } = params;
+        if (this._cache.promises) {
+            this._cache.promises.forEach((promise) => promise.reject(error));
+        }
+        delete this._cache.promises;
+    }
+    /**
+     * Return singleton value in a promise. If there is no cached value then try to get it from factory.
+     * @template T
+     * @returns {Promise<T>}
+     */
+    async promise() {
+        if ('singleton' in this._cache) {
+            return this._cache.singleton;
+        }
+        if ('promises' in this._cache) {
+            return new Promise((resolve, reject) => {
+                this._cache.promises.push({ reject, resolve });
+            });
+        }
+        this._cache.promises = [];
+        const result = await this._factory().catch((error) => {
+            this._rejectPromises({ error });
+            throw error;
+        });
+        this._cache.singleton = result;
+        this._cache.promises.forEach((promise) => promise.resolve(result));
+        delete this._cache.promises;
+        return result;
+    }
+    /**
+     * Return cached value, if there is no value cached return undefined.
+     * @template T
+     * @returns {T | undefined}
+     */
+    cached() {
+        if ('singleton' in this._cache) {
+            return this._cache.singleton;
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{src/singleton/pattern.ts → dist/singleton/pattern.d.ts}

@@ -1,5 +1,4 @@
-import { AnyFunctionNoParams } from 'src/types/any-function/no-params'
-
+export type AnyFunctionNoParams<T> = () => T;
 /**
  * Singleton patter wrapper function
  * @param {AnyFunctionNoParams<R>} factoryFn Factory function that is used to generate value that is going to be cached and return by
@@ -31,14 +30,5 @@ import { AnyFunctionNoParams } from 'src/types/any-function/no-params'
  * // using
  * console.log('NODE_ENV: ', config().env) // NODE_ENV: prod
  */
-export const singletonPattern = <R>(factoryFn: AnyFunctionNoParams<R>): AnyFunctionNoParams<R> => {
-	const cache: { singleton?: R } = {}
-
-	return (): R => {
-		if ('singleton' in cache) {
-			return cache.singleton!
-		}
-
-		return (cache.singleton = factoryFn())
-	}
-}
+export declare const singletonPattern: <R>(factoryFn: AnyFunctionNoParams<R>) => AnyFunctionNoParams<R>;
+//# sourceMappingURL=pattern.d.ts.map

package/dist/singleton/pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.d.ts","sourceRoot":"","sources":["../../src/singleton/pattern.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,MAAM,CAAC,CAAA;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,gBAAgB,iBAAkB,oBAAoB,CAAC,CAAC,KAAG,oBAAoB,CAAC,CAU5F,CAAA"}

package/dist/singleton/pattern.js

@@ -0,0 +1,41 @@
+/**
+ * Singleton patter wrapper function
+ * @param {AnyFunctionNoParams<R>} factoryFn Factory function that is used to generate value that is going to be cached and return by
+ * singleton.
+ * @return {AnyFunctionNoParams<R>} Function result that returns cached value.
+ * @example
+ * export class SomeClass {
+ *   constructor(protected _param: string){ }
+ *   get param(): string {
+ *     return this._param
+ *   }
+ * }
+ * export const someClassSingleton = singletonPattern((): SomeClass => {
+ *   return new SomeClass('some param value')
+ * })
+ *
+ * // using
+ * console.log('param: ', someClassSingleton().param) // param: some param value
+ *
+ * ///////////////////////////////////////////
+ * // Or we can use it with simple function //
+ * ///////////////////////////////////////////
+ * export const config = singletonPattern(() => {
+ *   return {
+ *     env: process.NODE_ENV,
+ *   } as const
+ * })
+ *
+ * // using
+ * console.log('NODE_ENV: ', config().env) // NODE_ENV: prod
+ */
+export const singletonPattern = (factoryFn) => {
+    const cache = {};
+    return () => {
+        if ('singleton' in cache) {
+            return cache.singleton;
+        }
+        return (cache.singleton = factoryFn());
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/string-util.d.ts

@@ -0,0 +1,10 @@
+export declare const stringUtil: {
+    /**
+     * Generate random UUID
+     * @return {string}
+     * @example
+     * console.log(stringUtil.uuid()) // "69bfda25-df3f-46b4-8bbb-955cf5193426"
+     */
+    generateUUID: () => string;
+};
+//# sourceMappingURL=string-util.d.ts.map

package/dist/string-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-util.d.ts","sourceRoot":"","sources":["../src/string-util.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;IACtB;;;;;OAKG;wBACe,MAAM;CAUxB,CAAA"}

package/dist/string-util.js

@@ -0,0 +1,18 @@
+export const stringUtil = {
+    /**
+     * Generate random UUID
+     * @return {string}
+     * @example
+     * console.log(stringUtil.uuid()) // "69bfda25-df3f-46b4-8bbb-955cf5193426"
+     */
+    generateUUID: () => {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            if (c == 'x') {
+                return r.toString(16);
+            }
+            return ((r & 0x3) | 0x8).toString(16);
+        });
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5nLXV0aWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvc3RyaW5nLXV0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3pCOzs7OztPQUtHO0lBQ0gsWUFBWSxFQUFFLEdBQVcsRUFBRTtRQUMxQixPQUFPLHNDQUFzQyxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRTtZQUNwRSxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsR0FBRyxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUE7WUFDbEMsSUFBSSxDQUFDLElBQUksR0FBRyxFQUFFLENBQUM7Z0JBQ2QsT0FBTyxDQUFDLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFBO1lBQ3RCLENBQUM7WUFFRCxPQUFPLENBQUMsQ0FBQyxDQUFDLEdBQUcsR0FBRyxDQUFDLEdBQUcsR0FBRyxDQUFDLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFBO1FBQ3RDLENBQUMsQ0FBQyxDQUFBO0lBQ0gsQ0FBQztDQUNELENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3Qgc3RyaW5nVXRpbCA9IHtcblx0LyoqXG5cdCAqIEdlbmVyYXRlIHJhbmRvbSBVVUlEXG5cdCAqIEByZXR1cm4ge3N0cmluZ31cblx0ICogQGV4YW1wbGVcblx0ICogY29uc29sZS5sb2coc3RyaW5nVXRpbC51dWlkKCkpIC8vIFwiNjliZmRhMjUtZGYzZi00NmI0LThiYmItOTU1Y2Y1MTkzNDI2XCJcblx0ICovXG5cdGdlbmVyYXRlVVVJRDogKCk6IHN0cmluZyA9PiB7XG5cdFx0cmV0dXJuICd4eHh4eHh4eC14eHh4LTR4eHgteXh4eC14eHh4eHh4eHh4eHgnLnJlcGxhY2UoL1t4eV0vZywgKGMpID0+IHtcblx0XHRcdGNvbnN0IHIgPSAoTWF0aC5yYW5kb20oKSAqIDE2KSB8IDBcblx0XHRcdGlmIChjID09ICd4Jykge1xuXHRcdFx0XHRyZXR1cm4gci50b1N0cmluZygxNilcblx0XHRcdH1cblxuXHRcdFx0cmV0dXJuICgociAmIDB4MykgfCAweDgpLnRvU3RyaW5nKDE2KVxuXHRcdH0pXG5cdH0sXG59XG4iXX0=

package/dist/time-util.d.ts

@@ -0,0 +1,74 @@
+export declare enum DurationUnit {
+    MILLISECOND = "MILLISECOND",
+    SECOND = "SECOND",
+    MINUTE = "MINUTE",
+    HOUR = "HOUR",
+    DAY = "DAY",
+    WEEK = "WEEK",
+    MONTH = "MONTH",
+    YEAR = "YEAR"
+}
+export type DurationUnitType = `${DurationUnit}`;
+export declare class TimeUtil {
+    /**
+     * return date object with the current time
+     * @return {Date}
+     * @example
+     * console.log(new TimeUtil().now().toISOString()) // 2023-03-08T19:45:01.991Z
+     */
+    now(): Date;
+    /**
+     * Convert date object to unix timestamp (milliseconds)
+     * @param {Date} date
+     * @return {number}
+     * @example
+     * // timeUtil.now().toISOString() === 2023-03-08T19:45:01.991Z
+     * const timeUtil = new TimeUtil()
+     * console.log(timeUtil.dateToUnix(timeUtil.now())) // 1678304701991
+     */
+    dateToUnix(date: Date): number;
+    /**
+     * Convert date object to unix timestamp (seconds)
+     * @param {Date} date
+     * @return {number}
+     * @example
+     * // timeUtil.now().toISOString() === 2023-03-08T19:45:01.991Z
+     * const timeUtil = new TimeUtil()
+     * console.log(timeUtil.dateToUnix(timeUtil.now())) // 1678304701
+     */
+    dateToUnixSec(date: Date): number;
+    /**
+     * Convert unix timestamp (milliseconds) to date object
+     * @param {number} unix
+     * @return {Date}
+     * @example
+     * const timeUtil = new TimeUtil()
+     * console.log(timeUtil.unixToDate(1678304701991).toISOString()) // 2023-03-08T19:45:01.991Z
+     */
+    unixToDate(unix: number): Date;
+    /**
+     * Convert unix timestamp (seconds) to date object
+     * @param {number} unix
+     * @return {Date}
+     * @example
+     * const timeUtil = new TimeUtil()
+     * console.log(timeUtil.unixToDate(1678304701).toISOString()) // 2023-03-08T19:45:01.000Z
+     */
+    unixSecToDate(unix: number): Date;
+    /**
+     * Change the value of date by unit/value pare.
+     * @param {{units: DurationUnitType, value: number, date: Date}} params
+     * @return {Date}
+     * @example
+     * // timeUtil.now().toISOString() === 2023-03-08T19:45:01.991Z
+     * const timeUtil = new TimeUtil()
+     * console.log(timeUtil.addToDate({date: timeUtil.now(), unit: 'DAY', value: 1 }).toISOString()) // 2023-03-09T19:45:01.991Z
+     * console.log(timeUtil.addToDate({date: timeUtil.now(), unit: DurationUnit.MONTH, value: -1 }).toISOString()) //2023-02-08T19:45:01.991Z
+     */
+    addToDate(params: {
+        unit: DurationUnitType | DurationUnit;
+        value: number;
+        date: Date;
+    }): Date;
+}
+//# sourceMappingURL=time-util.d.ts.map

package/dist/time-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-util.d.ts","sourceRoot":"","sources":["../src/time-util.ts"],"names":[],"mappings":"AAKA,oBAAY,YAAY;IACvB,WAAW,gBAAgB;IAC3B,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,IAAI,SAAS;IACb,KAAK,UAAU;IACf,IAAI,SAAS;CACb;AAED,MAAM,MAAM,gBAAgB,GAAG,GAAG,YAAY,EAAE,CAAA;AAEhD,qBAAa,QAAQ;IACpB;;;;;OAKG;IACH,GAAG,IAAI,IAAI;IAIX;;;;;;;;OAQG;IACH,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAI9B;;;;;;;;OAQG;IACH,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAIjC;;;;;;;OAOG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI9B;;;;;;;OAOG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIjC;;;;;;;;;OASG;IACH,SAAS,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,gBAAgB,GAAG,YAAY,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,CAAA;KAAE,GAAG,IAAI;CAQ7F"}

package/dist/time-util.js

@@ -0,0 +1,90 @@
+import add from 'date-fns/add/index.js';
+import addMilliseconds from 'date-fns/addMilliseconds/index.js';
+import format from 'date-fns/format/index.js';
+import parse from 'date-fns/parse/index.js';
+export var DurationUnit;
+(function (DurationUnit) {
+    DurationUnit["MILLISECOND"] = "MILLISECOND";
+    DurationUnit["SECOND"] = "SECOND";
+    DurationUnit["MINUTE"] = "MINUTE";
+    DurationUnit["HOUR"] = "HOUR";
+    DurationUnit["DAY"] = "DAY";
+    DurationUnit["WEEK"] = "WEEK";
+    DurationUnit["MONTH"] = "MONTH";
+    DurationUnit["YEAR"] = "YEAR";
+})(DurationUnit || (DurationUnit = {}));
+export class TimeUtil {
+    /**
+     * return date object with the current time
+     * @return {Date}
+     * @example
+     * console.log(new TimeUtil().now().toISOString()) // 2023-03-08T19:45:01.991Z
+     */
+    now() {
+        return new Date();
+    }
+    /**
+     * Convert date object to unix timestamp (milliseconds)
+     * @param {Date} date
+     * @return {number}
+     * @example
+     * // timeUtil.now().toISOString() === 2023-03-08T19:45:01.991Z
+     * const timeUtil = new TimeUtil()
+     * console.log(timeUtil.dateToUnix(timeUtil.now())) // 1678304701991
+     */
+    dateToUnix(date) {
+        return +format(date, 'T');
+    }
+    /**
+     * Convert date object to unix timestamp (seconds)
+     * @param {Date} date
+     * @return {number}
+     * @example
+     * // timeUtil.now().toISOString() === 2023-03-08T19:45:01.991Z
+     * const timeUtil = new TimeUtil()
+     * console.log(timeUtil.dateToUnix(timeUtil.now())) // 1678304701
+     */
+    dateToUnixSec(date) {
+        return +format(date, 't');
+    }
+    /**
+     * Convert unix timestamp (milliseconds) to date object
+     * @param {number} unix
+     * @return {Date}
+     * @example
+     * const timeUtil = new TimeUtil()
+     * console.log(timeUtil.unixToDate(1678304701991).toISOString()) // 2023-03-08T19:45:01.991Z
+     */
+    unixToDate(unix) {
+        return parse(unix.toString(), 'T', this.now());
+    }
+    /**
+     * Convert unix timestamp (seconds) to date object
+     * @param {number} unix
+     * @return {Date}
+     * @example
+     * const timeUtil = new TimeUtil()
+     * console.log(timeUtil.unixToDate(1678304701).toISOString()) // 2023-03-08T19:45:01.000Z
+     */
+    unixSecToDate(unix) {
+        return parse(unix.toString(), 't', this.now());
+    }
+    /**
+     * Change the value of date by unit/value pare.
+     * @param {{units: DurationUnitType, value: number, date: Date}} params
+     * @return {Date}
+     * @example
+     * // timeUtil.now().toISOString() === 2023-03-08T19:45:01.991Z
+     * const timeUtil = new TimeUtil()
+     * console.log(timeUtil.addToDate({date: timeUtil.now(), unit: 'DAY', value: 1 }).toISOString()) // 2023-03-09T19:45:01.991Z
+     * console.log(timeUtil.addToDate({date: timeUtil.now(), unit: DurationUnit.MONTH, value: -1 }).toISOString()) //2023-02-08T19:45:01.991Z
+     */
+    addToDate(params) {
+        const { date, unit, value } = params;
+        if (`${unit}` === 'MILLISECOND') {
+            return addMilliseconds(date, value);
+        }
+        return add(date, { [`${unit.toLowerCase()}s`]: value });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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