@beecode/msh-util 1.2.0 → 1.2.1

package/src/time-util.test.ts

@@ -0,0 +1,89 @@
+import { DurationUnit, DurationUnitType, TimeUtil } from 'src/time-util'
+
+describe('TimeUtil', () => {
+	const constantNowDate = new Date('2022-01-01T00:00:00.000Z')
+	const constantNowUnix = 1640995200000 // 2022-01-01T00:00:00 UTC
+	const constantNowUnixSec = 1640995200 // 2022-01-01T00:00:00 UTC
+	const timeUtil = new TimeUtil()
+
+	beforeAll(() => {
+		jest.useFakeTimers('modern' as any)
+		jest.setSystemTime(constantNowDate.getTime())
+	})
+
+	afterAll(() => {
+		jest.useRealTimers()
+	})
+
+	describe('now', () => {
+		it('should return mocked date', () => {
+			expect(timeUtil.now().toISOString()).toEqual(constantNowDate.toISOString())
+		})
+	})
+
+	describe('dateToUnix', () => {
+		it('should convert constant date to constant unix', () => {
+			expect(timeUtil.dateToUnix(timeUtil.now())).toEqual(constantNowUnix)
+		})
+	})
+
+	describe('dateToUnixSec', () => {
+		it('should convert constant date to constant unixSec', () => {
+			expect(timeUtil.dateToUnixSec(timeUtil.now())).toEqual(constantNowUnixSec)
+		})
+	})
+
+	describe('unixToDate', () => {
+		it('should convert constant date to constant unix', () => {
+			expect(timeUtil.unixToDate(constantNowUnix)).toEqual(timeUtil.now())
+		})
+	})
+
+	describe('unixSecToDate', () => {
+		it('should convert constant date to constant unixSec', () => {
+			expect(timeUtil.unixSecToDate(constantNowUnixSec)).toEqual(timeUtil.now())
+		})
+	})
+
+	describe('addToDate', () => {
+		it.each([
+			[DurationUnit.MILLISECOND, 1, new Date('2022-01-01T00:00:00.001Z')],
+			[DurationUnit.SECOND, 1, new Date('2022-01-01T00:00:01.000Z')],
+			[DurationUnit.MINUTE, 1, new Date('2022-01-01T00:01:00.000Z')],
+			[DurationUnit.HOUR, 1, new Date('2022-01-01T01:00:00.000Z')],
+			[DurationUnit.DAY, 1, new Date('2022-01-02T00:00:00.000Z')],
+			[DurationUnit.WEEK, 1, new Date('2022-01-08T00:00:00.000Z')],
+			[DurationUnit.MONTH, 1, new Date('2022-02-01T00:00:00.000Z')],
+			[DurationUnit.YEAR, 1, new Date('2023-01-01T00:00:00.000Z')],
+			[DurationUnit.MILLISECOND, -1, new Date('2021-12-31T23:59:59.999Z')],
+			[DurationUnit.SECOND, -1, new Date('2021-12-31T23:59:59.000Z')],
+			[DurationUnit.MINUTE, -1, new Date('2021-12-31T23:59:00.000Z')],
+			[DurationUnit.HOUR, -1, new Date('2021-12-31T23:00:00.000Z')],
+			[DurationUnit.DAY, -1, new Date('2021-12-31T00:00:00.000Z')],
+			[DurationUnit.WEEK, -1, new Date('2021-12-25T00:00:00.000Z')],
+			[DurationUnit.MONTH, -1, new Date('2021-12-01T00:00:00.000Z')],
+			[DurationUnit.YEAR, -1, new Date('2021-01-01T00:00:00.000Z')],
+			['MILLISECOND', 1, new Date('2022-01-01T00:00:00.001Z')],
+			['SECOND', 1, new Date('2022-01-01T00:00:01.000Z')],
+			['MINUTE', 1, new Date('2022-01-01T00:01:00.000Z')],
+			['HOUR', 1, new Date('2022-01-01T01:00:00.000Z')],
+			['DAY', 1, new Date('2022-01-02T00:00:00.000Z')],
+			['WEEK', 1, new Date('2022-01-08T00:00:00.000Z')],
+			['MONTH', 1, new Date('2022-02-01T00:00:00.000Z')],
+			['YEAR', 1, new Date('2023-01-01T00:00:00.000Z')],
+			['MILLISECOND', -1, new Date('2021-12-31T23:59:59.999Z')],
+			['SECOND', -1, new Date('2021-12-31T23:59:59.000Z')],
+			['MINUTE', -1, new Date('2021-12-31T23:59:00.000Z')],
+			['HOUR', -1, new Date('2021-12-31T23:00:00.000Z')],
+			['DAY', -1, new Date('2021-12-31T00:00:00.000Z')],
+			['WEEK', -1, new Date('2021-12-25T00:00:00.000Z')],
+			['MONTH', -1, new Date('2021-12-01T00:00:00.000Z')],
+			['YEAR', -1, new Date('2021-01-01T00:00:00.000Z')],
+		] as [DurationUnitType | DurationUnit, number, Date][])(
+			'%#. should increase date by unit %s and value %s and get date $s',
+			(unit, value, expected) => {
+				expect(timeUtil.addToDate({ date: timeUtil.now(), unit, value })).toEqual(expected)
+			}
+		)
+	})
+})

package/src/time-util.ts

@@ -0,0 +1,98 @@
+import add from 'date-fns/add'
+import addMilliseconds from 'date-fns/addMilliseconds'
+import format from 'date-fns/format'
+import parse from 'date-fns/parse'
+
+export enum DurationUnit {
+	MILLISECOND = 'MILLISECOND',
+	SECOND = 'SECOND',
+	MINUTE = 'MINUTE',
+	HOUR = 'HOUR',
+	DAY = 'DAY',
+	WEEK = 'WEEK',
+	MONTH = 'MONTH',
+	YEAR = 'YEAR',
+}
+
+export type DurationUnitType = `${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(): Date {
+		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: Date): number {
+		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: Date): number {
+		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: number): Date {
+		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: number): Date {
+		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: { unit: DurationUnitType | DurationUnit; value: number; date: Date }): Date {
+		const { date, unit, value } = params
+		if (`${unit}` === 'MILLISECOND') {
+			return addMilliseconds(date, value)
+		}
+
+		return add(date, { [`${unit.toLowerCase()}s`]: value })
+	}
+}

package/src/timeout.test.ts

@@ -0,0 +1,65 @@
+import { timeout } from 'src/timeout'
+
+describe('timeout', () => {
+	const fn_one = jest.fn()
+	const fn_two = jest.fn()
+	const fn_three = jest.fn()
+	const fn_onResolve = jest.fn()
+
+	const timeoutImplementation = async (): Promise<void> => {
+		fn_one()
+		await timeout(1000)
+		fn_two()
+		await timeout(1000)
+		fn_three()
+	}
+
+	beforeEach(() => {
+		jest.useFakeTimers()
+	})
+
+	afterEach(() => {
+		jest.clearAllTimers()
+		jest.useRealTimers()
+		jest.resetAllMocks()
+	})
+
+	it('should function one by one with pause of 1000ms', async () => {
+		expect(fn_one).toHaveBeenCalledTimes(0)
+		expect(fn_two).toHaveBeenCalledTimes(0)
+		expect(fn_three).toHaveBeenCalledTimes(0)
+		expect(fn_onResolve).toHaveBeenCalledTimes(0)
+
+		const promise1 = timeoutImplementation().then(() => {
+			return fn_onResolve()
+		})
+
+		expect(fn_one).toHaveBeenCalledTimes(1)
+		expect(fn_two).toHaveBeenCalledTimes(0)
+		expect(fn_three).toHaveBeenCalledTimes(0)
+		expect(fn_onResolve).toHaveBeenCalledTimes(0)
+
+		jest.advanceTimersByTime(1000)
+		await Promise.resolve()
+
+		expect(fn_one).toHaveBeenCalledTimes(1)
+		expect(fn_two).toHaveBeenCalledTimes(1)
+		expect(fn_three).toHaveBeenCalledTimes(0)
+		expect(fn_onResolve).toHaveBeenCalledTimes(0)
+
+		jest.advanceTimersByTime(1000)
+		await Promise.resolve()
+
+		expect(fn_one).toHaveBeenCalledTimes(1)
+		expect(fn_two).toHaveBeenCalledTimes(1)
+		expect(fn_three).toHaveBeenCalledTimes(1)
+		expect(fn_onResolve).toHaveBeenCalledTimes(0)
+
+		await promise1
+
+		expect(fn_one).toHaveBeenCalledTimes(1)
+		expect(fn_two).toHaveBeenCalledTimes(1)
+		expect(fn_three).toHaveBeenCalledTimes(1)
+		expect(fn_onResolve).toHaveBeenCalledTimes(1)
+	})
+})

package/src/timeout.ts

@@ -0,0 +1,16 @@
+/**
+ *
+ * @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 const timeout = (ms: number): Promise<void> => {
+	return new Promise((resolve) => setTimeout(resolve, ms))
+}

package/src/type-util.test.ts

@@ -0,0 +1,20 @@
+import { typeUtil } from 'src/type-util'
+
+describe('typeUtil', () => {
+	describe('exhaustiveMessage', () => {
+		it('should return string', () => {
+			const testMessage = 'testMessage'
+			// @ts-ignore
+			expect(typeUtil.exhaustiveMessage(testMessage, '')).toEqual(testMessage)
+		})
+	})
+	describe('exhaustiveError', () => {
+		it('should return string', () => {
+			const testMessage = 'testMessage'
+			// @ts-ignore
+			const error = typeUtil.exhaustiveError(testMessage, '')
+			expect(error).toBeInstanceOf(Error)
+			expect(error.message).toEqual(testMessage)
+		})
+	})
+})

package/src/type-util.ts

@@ -0,0 +1,54 @@
+export const typeUtil = {
+	/**
+	 * 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 => {
+		return new Error(message)
+	},
+
+	/**
+	 * 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 => {
+		return message
+	},
+}

package/src/types/any-function/index.ts

@@ -0,0 +1 @@
+export type AnyFunction<T> = (...args: any[]) => T

package/src/types/any-function/no-params.ts

@@ -0,0 +1 @@
+export type AnyFunctionNoParams<T> = () => T

package/src/types/any-function/promise-no-params.ts

@@ -0,0 +1 @@
+export type AnyFunctionPromiseNoParams<T> = () => Promise<T>

package/src/types/any-function/promise.ts

@@ -0,0 +1 @@
+export type AnyFunctionPromise<T> = (...args: any[]) => Promise<T>

package/src/types/types.d.ts

@@ -0,0 +1,2 @@
+/* istanbul ignore file */
+import 'jest-extended'