@beecode/msh-util 1.0.1-alpha

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

@@ -0,0 +1,31 @@
+import { AnyFunctionPromiseNoParams } from './types/any-function/promise-no-params';
+/**
+ * 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/lib/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,OAAO,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAA;AAErF;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,sBAAsB,CAAC,CAAC;IACnC,SAAS,CAAC,MAAM,EAAE;QAChB,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;KAC9F,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;CAkB5B"}

package/lib/single-threshold-promise.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleThresholdPromise = void 0;
+/**
+ * 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()
+ *   }
+ * }
+ */
+class SingleThresholdPromise {
+    constructor(factoryFn) {
+        this._cache = {};
+        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({ resolve, reject });
+            });
+        }
+        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;
+    }
+}
+exports.SingleThresholdPromise = SingleThresholdPromise;
+//# sourceMappingURL=single-threshold-promise.js.map

package/lib/single-threshold-promise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-threshold-promise.js","sourceRoot":"","sources":["../src/single-threshold-promise.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAa,sBAAsB;IAOjC,YAAY,SAAwC;QAN1C,WAAM,GAEZ,EAAE,CAAA;QAKJ,IAAI,CAAC,UAAU,GAAG,SAAS,CAAA;IAC7B,CAAC;IAES,eAAe;QACvB,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAA;SAC1F;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAA;IAC7B,CAAC;IAED,KAAK,CAAC,OAAO;QACX,IAAI,UAAU,IAAI,IAAI,CAAC,MAAM,EAAE;YAC7B,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACxC,IAAI,CAAC,MAAM,CAAC,QAAS,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAA;YACjD,CAAC,CAAC,CAAA;SACH;QAED,IAAI,CAAC,MAAM,CAAC,QAAQ,GAAG,EAAE,CAAA;QACzB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;YACnD,IAAI,CAAC,eAAe,EAAE,CAAA;YACtB,MAAM,GAAG,CAAA;QACX,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAA;QAClE,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAA;QAE3B,OAAO,MAAM,CAAA;IACf,CAAC;CACF;AApCD,wDAoCC"}

package/lib/singleton/async.d.ts

@@ -0,0 +1,50 @@
+import { AnyFunctionPromiseNoParams } from '../types/any-function/promise-no-params';
+/**
+ * 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/lib/singleton/async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../../src/singleton/async.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAA;AAErF;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,cAAc,CAAC,CAAC;IAC3B,SAAS,CAAC,MAAM,EAAE;QAChB,SAAS,CAAC,EAAE,CAAC,CAAA;QACb,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;KAC9F,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;CAOxB"}

package/lib/singleton/async.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingletonAsync = void 0;
+/**
+ * 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' }
+ */
+class SingletonAsync {
+    constructor(factory) {
+        this._cache = {};
+        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({ resolve, reject });
+            });
+        }
+        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;
+    }
+}
+exports.SingletonAsync = SingletonAsync;
+//# sourceMappingURL=async.js.map

package/lib/singleton/async.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.js","sourceRoot":"","sources":["../../src/singleton/async.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAa,cAAc;IAQzB,YAAY,OAAsC;QAPxC,WAAM,GAGZ,EAAE,CAAA;QAKJ,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;IACzB,CAAC;IAED;;OAEG;IACH,UAAU;QACR,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAA;QAC5B,IAAI,CAAC,eAAe,CAAC,EAAE,KAAK,EAAE,IAAI,KAAK,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAA;IACjE,CAAC;IAES,eAAe,CAAC,MAAwB;QAChD,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,CAAA;QAExB,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;SACjE;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAA;IAC7B,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO;QACX,IAAI,WAAW,IAAI,IAAI,CAAC,MAAM,EAAE;YAC9B,OAAO,IAAI,CAAC,MAAM,CAAC,SAAU,CAAA;SAC9B;QACD,IAAI,UAAU,IAAI,IAAI,CAAC,MAAM,EAAE;YAC7B,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACxC,IAAI,CAAC,MAAM,CAAC,QAAS,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAA;YACjD,CAAC,CAAC,CAAA;SACH;QAED,IAAI,CAAC,MAAM,CAAC,QAAQ,GAAG,EAAE,CAAA;QACzB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YACnD,IAAI,CAAC,eAAe,CAAC,EAAE,KAAK,EAAE,CAAC,CAAA;YAC/B,MAAM,KAAK,CAAA;QACb,CAAC,CAAC,CAAA;QACF,IAAI,CAAC,MAAM,CAAC,SAAS,GAAG,MAAM,CAAA;QAE9B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAA;QAClE,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAA;QAE3B,OAAO,MAAM,CAAA;IACf,CAAC;IAED;;;;OAIG;IACH,MAAM;QACJ,IAAI,WAAW,IAAI,IAAI,CAAC,MAAM,EAAE;YAC9B,OAAO,IAAI,CAAC,MAAM,CAAC,SAAU,CAAA;SAC9B;QAED,OAAO,SAAS,CAAA;IAClB,CAAC;CACF;AArED,wCAqEC"}

package/lib/singleton/pattern.d.ts

@@ -0,0 +1,34 @@
+import { AnyFunctionNoParams } from '../types/any-function/no-params';
+/**
+ * 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 declare const singletonPattern: <R>(factoryFn: AnyFunctionNoParams<R>) => AnyFunctionNoParams<R>;
+//# sourceMappingURL=pattern.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.d.ts","sourceRoot":"","sources":["../../src/singleton/pattern.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAA;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,gBAAgB,kEAU5B,CAAA"}

package/lib/singleton/pattern.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.singletonPattern = void 0;
+/**
+ * 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
+ */
+const singletonPattern = (factoryFn) => {
+    const cache = {};
+    return () => {
+        if ('singleton' in cache) {
+            return cache.singleton;
+        }
+        return (cache.singleton = factoryFn());
+    };
+};
+exports.singletonPattern = singletonPattern;
+//# sourceMappingURL=pattern.js.map

package/lib/singleton/pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.js","sourceRoot":"","sources":["../../src/singleton/pattern.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACI,MAAM,gBAAgB,GAAG,CAAI,SAAiC,EAA0B,EAAE;IAC/F,MAAM,KAAK,GAAsB,EAAE,CAAA;IAEnC,OAAO,GAAM,EAAE;QACb,IAAI,WAAW,IAAI,KAAK,EAAE;YACxB,OAAO,KAAK,CAAC,SAAU,CAAA;SACxB;QAED,OAAO,CAAC,KAAK,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC,CAAA;IACxC,CAAC,CAAA;AACH,CAAC,CAAA;AAVY,QAAA,gBAAgB,oBAU5B"}

package/lib/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/lib/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;IACrB;;;;;OAKG;wBACe,MAAM;CAQzB,CAAA"}

package/lib/string-util.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringUtil = void 0;
+exports.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, function (c) {
+            const r = (Math.random() * 16) | 0;
+            const v = c == 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    },
+};
+//# sourceMappingURL=string-util.js.map

package/lib/string-util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-util.js","sourceRoot":"","sources":["../src/string-util.ts"],"names":[],"mappings":";;;AAAa,QAAA,UAAU,GAAG;IACxB;;;;;OAKG;IACH,YAAY,EAAE,GAAW,EAAE;QACzB,OAAO,sCAAsC,CAAC,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC;YACxE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAA;YAClC,MAAM,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAA;YAExC,OAAO,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAA;QACvB,CAAC,CAAC,CAAA;IACJ,CAAC;CACF,CAAA"}

package/lib/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/lib/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;IACtB,WAAW,gBAAgB;IAC3B,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,IAAI,SAAS;IACb,KAAK,UAAU;IACf,IAAI,SAAS;CACd;AAED,MAAM,MAAM,gBAAgB,GAAG,GAAG,YAAY,EAAE,CAAA;AAEhD,qBAAa,QAAQ;IACnB;;;;;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;CAQ9F"}

package/lib/time-util.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeUtil = exports.DurationUnit = void 0;
+const add_1 = __importDefault(require("date-fns/add"));
+const addMilliseconds_1 = __importDefault(require("date-fns/addMilliseconds"));
+const format_1 = __importDefault(require("date-fns/format"));
+const parse_1 = __importDefault(require("date-fns/parse"));
+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 = exports.DurationUnit || (exports.DurationUnit = {}));
+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 +(0, format_1.default)(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 +(0, format_1.default)(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 (0, parse_1.default)(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 (0, parse_1.default)(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 (0, addMilliseconds_1.default)(date, value);
+        }
+        return (0, add_1.default)(date, { [`${unit.toLowerCase()}s`]: value });
+    }
+}
+exports.TimeUtil = TimeUtil;
+//# sourceMappingURL=time-util.js.map

package/lib/time-util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-util.js","sourceRoot":"","sources":["../src/time-util.ts"],"names":[],"mappings":";;;;;;AAAA,uDAA8B;AAC9B,+EAAsD;AACtD,6DAAoC;AACpC,2DAAkC;AAElC,IAAY,YASX;AATD,WAAY,YAAY;IACtB,2CAA2B,CAAA;IAC3B,iCAAiB,CAAA;IACjB,iCAAiB,CAAA;IACjB,6BAAa,CAAA;IACb,2BAAW,CAAA;IACX,6BAAa,CAAA;IACb,+BAAe,CAAA;IACf,6BAAa,CAAA;AACf,CAAC,EATW,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QASvB;AAID,MAAa,QAAQ;IACnB;;;;;OAKG;IACH,GAAG;QACD,OAAO,IAAI,IAAI,EAAE,CAAA;IACnB,CAAC;IAED;;;;;;;;OAQG;IACH,UAAU,CAAC,IAAU;QACnB,OAAO,CAAC,IAAA,gBAAM,EAAC,IAAI,EAAE,GAAG,CAAC,CAAA;IAC3B,CAAC;IAED;;;;;;;;OAQG;IACH,aAAa,CAAC,IAAU;QACtB,OAAO,CAAC,IAAA,gBAAM,EAAC,IAAI,EAAE,GAAG,CAAC,CAAA;IAC3B,CAAC;IAED;;;;;;;OAOG;IACH,UAAU,CAAC,IAAY;QACrB,OAAO,IAAA,eAAK,EAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,CAAA;IAChD,CAAC;IAED;;;;;;;OAOG;IACH,aAAa,CAAC,IAAY;QACxB,OAAO,IAAA,eAAK,EAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,CAAA;IAChD,CAAC;IAED;;;;;;;;;OASG;IACH,SAAS,CAAC,MAA4E;QACpF,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,CAAA;QACpC,IAAI,GAAG,IAAI,EAAE,KAAK,aAAa,EAAE;YAC/B,OAAO,IAAA,yBAAe,EAAC,IAAI,EAAE,KAAK,CAAC,CAAA;SACpC;QAED,OAAO,IAAA,aAAG,EAAC,IAAI,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAA;IACzD,CAAC;CACF;AA/ED,4BA+EC"}

package/lib/timeout.d.ts

@@ -0,0 +1,15 @@
+/**
+ *
+ * @param {number} ms The time, in milliseconds that the timer should wait before the specified function or code is executed. If this parameter is omitted, a value of 0 is used, meaning execute "immediately", or more accurately, the next event cycle.
+ * @return {Promise<void>}
+ * @example
+ * const lightBlink = (): void => {
+ *   turnLightOn()
+ *   timeout(3000) // wait for 3 seconds
+ *   turnLightOff()
+ *   timeout(3000) // wait for 3 seconds
+ *   turnLightOn()
+ * }
+ */
+export declare const timeout: (ms: number) => Promise<void>;
+//# sourceMappingURL=timeout.d.ts.map

package/lib/timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../src/timeout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,OAAQ,MAAM,KAAG,QAAQ,IAAI,CAEhD,CAAA"}

package/lib/timeout.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeout = void 0;
+/**
+ *
+ * @param {number} ms The time, in milliseconds that the timer should wait before the specified function or code is executed. If this parameter is omitted, a value of 0 is used, meaning execute "immediately", or more accurately, the next event cycle.
+ * @return {Promise<void>}
+ * @example
+ * const lightBlink = (): void => {
+ *   turnLightOn()
+ *   timeout(3000) // wait for 3 seconds
+ *   turnLightOff()
+ *   timeout(3000) // wait for 3 seconds
+ *   turnLightOn()
+ * }
+ */
+const timeout = (ms) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+};
+exports.timeout = timeout;
+//# sourceMappingURL=timeout.js.map

package/lib/timeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.js","sourceRoot":"","sources":["../src/timeout.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;GAYG;AACI,MAAM,OAAO,GAAG,CAAC,EAAU,EAAiB,EAAE;IACnD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAA;AAC1D,CAAC,CAAA;AAFY,QAAA,OAAO,WAEnB"}

package/lib/type-util.d.ts

@@ -0,0 +1,50 @@
+export declare const typeUtil: {
+    /**
+     * In TypeScript, exhaustiveMessage is a technique that can be used with switch statements to ensure that all possible cases are handled.
+     *
+     * When using switch statements, it is common to have a default case that handles any unanticipated cases. However, sometimes it is important to ensure that all cases are explicitly handled to avoid potential errors or bugs in the code.
+     * @param {string} message
+     * @param {never} _
+     * @return {string}
+     * @example
+     * export type Animal = 'cat' | 'dog' | 'bird';
+     *
+     * export const makeSound = (animal: Animal): string => {
+     *   switch (animal) {
+     *     case 'cat':
+     *       return 'Meow'
+     *     case 'dog':
+     *       return 'Woof'
+     *     case 'bird':
+     *       return 'Tweet'
+     *     default:
+     *       console.error(new TypeUtil().exhaustiveMessage('Unknown animal [animal]', animal))
+     *       return 'unknown sound'
+     *   }
+     * }
+     */
+    exhaustiveMessage: (message: string, _: never) => string;
+    /**
+     * This is the similar to exhaustiveMessage, but instead of message we are returning error so we can throw it
+     * @param {string} message
+     * @param {never} _
+     * @return {Error}
+     * @example
+     * export type Animal = 'cat' | 'dog' | 'bird';
+     *
+     * export const makeSound = (animal: Animal): string => {
+     *   switch (animal) {
+     *     case 'cat':
+     *       return 'Meow'
+     *     case 'dog':
+     *       return 'Woof'
+     *     case 'bird':
+     *       return 'Tweet'
+     *     default:
+     *       throw typeUtil.exhaustiveError('Unknown animal [animal]', animal)
+     *   }
+     * }
+     */
+    exhaustiveError: (message: string, _: never) => Error;
+};
+//# sourceMappingURL=type-util.d.ts.map

package/lib/type-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-util.d.ts","sourceRoot":"","sources":["../src/type-util.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ;IACnB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;iCAC0B,MAAM,KAAK,KAAK,KAAG,MAAM;IAItD;;;;;;;;;;;;;;;;;;;;OAoBG;+BACwB,MAAM,KAAK,KAAK,KAAG,KAAK;CAGpD,CAAA"}