@beecode/msh-util 1.2.1 → 2.0.0

package/src/singleton/async.test.ts

@@ -1,122 +0,0 @@
-import { SingletonAsync } from 'src/singleton/async'
-import { timeout } from 'src/timeout'
-
-describe('SingletonAsync', () => {
-	const fakeResult = { sucessful: true }
-	const fake_asyncFactoryFn = jest.fn()
-	const fake_asyncRejectFactoryFn = jest.fn()
-	beforeEach(() => {
-		jest.useFakeTimers()
-		fake_asyncFactoryFn.mockImplementation(async (): Promise<{ sucessful: boolean }> => {
-			await timeout(1000)
-
-			return fakeResult
-		})
-		fake_asyncRejectFactoryFn.mockImplementation(async (): Promise<{ sucessful: boolean }> => {
-			await timeout(1000)
-			throw new Error()
-		})
-	})
-
-	afterEach(() => {
-		jest.clearAllTimers()
-		jest.useRealTimers()
-		jest.resetAllMocks()
-	})
-	describe('promise', () => {
-		it('should return promised value', async () => {
-			const singletonImplementation = new SingletonAsync(fake_asyncFactoryFn)
-			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
-			const promise = singletonImplementation.promise()
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
-			jest.runAllTimers()
-			expect(await promise).toBe(fakeResult)
-		})
-
-		it('should subscribe multiple calls to the same promise if promise still not resolved', async () => {
-			const singletonImplementation = new SingletonAsync(fake_asyncFactoryFn)
-			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
-			const promise1 = singletonImplementation.promise()
-			const promise2 = singletonImplementation.promise()
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
-
-			jest.runAllTimers()
-			expect(await promise1).toBe(fakeResult)
-			expect(await promise2).toBe(fakeResult)
-		})
-
-		it('should second call after promise is resolved should return cache value', async () => {
-			const singletonImplementation = new SingletonAsync(fake_asyncFactoryFn)
-			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
-			const promise1 = singletonImplementation.promise()
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
-
-			jest.runAllTimers()
-			expect(await promise1).toBe(fakeResult)
-
-			const promise2 = singletonImplementation.promise()
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
-			jest.runAllTimers()
-			expect(await promise2).toBe(fakeResult)
-		})
-
-		it('should reject all subscribers to promise if it is rejected', async () => {
-			const singletonImplementation = new SingletonAsync(fake_asyncRejectFactoryFn)
-			expect(fake_asyncRejectFactoryFn).not.toHaveBeenCalled()
-			const promise1 = singletonImplementation.promise()
-			const promise2 = singletonImplementation.promise()
-			expect(fake_asyncRejectFactoryFn).toHaveBeenCalledTimes(1)
-
-			jest.runAllTimers()
-			await promise1.then(() => expect.fail('test failed')).catch(() => undefined)
-			await promise2.then(() => expect.fail('test failed')).catch(() => undefined)
-		})
-	})
-	describe('cached', () => {
-		it('should return undefined if promise is never called', () => {
-			const singletonImplementation = new SingletonAsync(fake_asyncFactoryFn)
-			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
-			expect(singletonImplementation.cached()).toBeUndefined()
-		})
-		it('should cache result of the promise', async () => {
-			const singletonImplementation = new SingletonAsync(fake_asyncFactoryFn)
-			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
-
-			const promise = singletonImplementation.promise()
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
-			jest.runAllTimers()
-			expect(await promise).toBe(fakeResult)
-			expect(singletonImplementation.cached()).toBe(fakeResult)
-		})
-	})
-	describe('cleanCache', () => {
-		it('should reject all subscribers to the promise if cleanCache is called before promise is resolved', async () => {
-			const singletonImplementation = new SingletonAsync(fake_asyncFactoryFn)
-			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
-			const promise1 = singletonImplementation.promise().catch(() => undefined)
-			const promise2 = singletonImplementation.promise().catch(() => undefined)
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
-			singletonImplementation.cleanCache()
-			jest.runAllTimers()
-			await promise1.then(() => expect.fail('test failed'))
-			await promise2.then(() => expect.fail('test failed'))
-		})
-
-		it('should clean cache and after the clean cache factory should be called again on promise', async () => {
-			const singletonImplementation = new SingletonAsync(fake_asyncFactoryFn)
-			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
-			const promise1 = singletonImplementation.promise()
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
-			jest.runAllTimers()
-			expect(await promise1).toBe(fakeResult)
-			expect(singletonImplementation.cached()).toBe(fakeResult)
-			singletonImplementation.cleanCache()
-			expect(singletonImplementation.cached()).toBeUndefined()
-
-			const promise2 = singletonImplementation.promise()
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(2)
-			jest.runAllTimers()
-			expect(await promise2).toBe(fakeResult)
-		})
-	})
-})

package/src/singleton/async.ts

@@ -1,90 +0,0 @@
-import { AnyFunctionPromiseNoParams } from 'src/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 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>) {
-		this._factory = factory
-	}
-
-	/**
-	 * Empty cached value and reject any subscribed promise that is waiting for the initial promise to be resolved.
-	 */
-	cleanCache(): void {
-		delete this._cache.singleton
-		this._rejectPromises({ error: new Error('Cache was cleaned') })
-	}
-
-	protected _rejectPromises(params: { error: Error }): void {
-		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(): Promise<T> {
-		if ('singleton' in this._cache) {
-			return this._cache.singleton!
-		}
-		if ('promises' in this._cache) {
-			return new Promise<T>((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(): T | undefined {
-		if ('singleton' in this._cache) {
-			return this._cache.singleton!
-		}
-
-		return undefined
-	}
-}

package/src/singleton/pattern.test.ts

@@ -1,16 +0,0 @@
-import { singletonPattern } from 'src/singleton/pattern'
-
-describe('singletonPattern', () => {
-	it('should call factory function only once', () => {
-		const factoryResult = { successful: true }
-		const factoryFn = jest.fn().mockImplementation(() => {
-			return factoryResult
-		})
-		const singletonImplementation = singletonPattern(factoryFn)
-		expect(factoryFn).not.toHaveBeenCalled()
-		expect(singletonImplementation()).toBe(factoryResult)
-		expect(factoryFn).toHaveBeenCalledTimes(1)
-		expect(singletonImplementation()).toBe(factoryResult)
-		expect(factoryFn).toHaveBeenCalledTimes(1)
-	})
-})

package/src/string-util.test.ts

@@ -1,18 +0,0 @@
-import { regexUtil } from 'src/regex-util'
-import { stringUtil } from 'src/string-util'
-
-describe('stringUtil', () => {
-	it.each([
-		[stringUtil.generateUUID()],
-		[stringUtil.generateUUID()],
-		[stringUtil.generateUUID()],
-		[stringUtil.generateUUID()],
-		[stringUtil.generateUUID()],
-		[stringUtil.generateUUID()],
-		[stringUtil.generateUUID()],
-		[stringUtil.generateUUID()],
-		[stringUtil.generateUUID()],
-	])('%#. should generate valid uuid %s', (uuid) => {
-		expect(new RegExp(regexUtil.uuid).test(uuid)).toBeTruthy()
-	})
-})

package/src/string-util.ts

@@ -1,18 +0,0 @@
-export const stringUtil = {
-	/**
-	 * Generate random UUID
-	 * @return {string}
-	 * @example
-	 * console.log(stringUtil.uuid()) // "69bfda25-df3f-46b4-8bbb-955cf5193426"
-	 */
-	generateUUID: (): string => {
-		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)
-		})
-	},
-}

package/src/time-util.test.ts

@@ -1,89 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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/type-util.test.ts

@@ -1,20 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

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

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

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

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

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

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

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

package/src/types/types.d.ts

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