@beecode/msh-util 1.2.1 → 2.0.0

package/src/object-util.test.ts

@@ -1,360 +0,0 @@
-import { ObjectUtil } from 'src/object-util'
-
-/* eslint-disable sort-keys-fix/sort-keys-fix */
-describe('objectUtil', () => {
-	const objectUtil = new ObjectUtil()
-
-	const everyType = {
-		number: 1,
-		decimal: 1.12345,
-		string: 'string',
-		undefined: undefined,
-		notANumber: NaN,
-		emptyObj: {},
-		date: new Date('2020-01-01'),
-		boolean: true,
-		nestedObject: { obj: 'test' },
-	}
-
-	const everyTypeReversed = {
-		nestedObject: { obj: 'test' },
-		boolean: true,
-		date: new Date('2020-01-01'),
-		emptyObj: {},
-		notANumber: NaN,
-		undefined: undefined,
-		string: 'string',
-		decimal: 1.12345,
-		number: 1,
-	}
-
-	describe('deepClone', () => {
-		it.each([
-			[{ test: 'string' }],
-			[{ deep: { test: 'string' } }],
-			[{ deeper: { deep: { test: 'string' } } }],
-			[everyType],
-			[{ deep: everyType }],
-			[{ deeper: { deep: everyType } }],
-		])('%#. should clone %j', (obj) => {
-			expect(objectUtil.deepClone(obj)).not.toBe(obj)
-		})
-	})
-
-	describe('pickByList', () => {
-		it.each([
-			[['a', 'b'], { a: 1, b: '2', c: 3 }, { a: 1, b: '2' }],
-			[['a', 'c'], { a: 1, b: '2', c: 3 }, { a: 1, c: 3 }],
-		])('%#. should pick only this properties [%s] from object %s and return object %s', (propList, obj, result) => {
-			expect(objectUtil.pickByList(obj, propList)).toEqual(result)
-		})
-	})
-
-	describe('pickByObjectKeys', () => {
-		it.each([
-			[
-				{ a: 1, b: '2', c: 3 },
-				{ a: '', b: '' },
-				{ a: 1, b: '2' },
-			],
-			[
-				{ a: 1, b: '2', c: 3 },
-				{ a: '', c: '' },
-				{ a: 1, c: 3 },
-			],
-		])('%#. should pick form this %s using keys from %s and return %s', (obj, objWithPickKeys, result) => {
-			expect(objectUtil.pickByObjectKeys(obj, objWithPickKeys)).toEqual(result)
-		})
-	})
-
-	describe('deepStringify', () => {
-		it.each([
-			[{}, '{}'],
-			[{ a: 1, b: 2 }, `{ a: 1, b: 2 }`],
-			[
-				everyType,
-				`{ boolean: true, date: 2020-01-01T00:00:00.000Z, decimal: 1.12345, emptyObj: {}, nestedObject: { obj: 'test' }, notANumber: NaN, number: 1, string: 'string', undefined: undefined }`,
-			],
-			[
-				{ deep: everyType },
-				`{ deep: { boolean: true, date: 2020-01-01T00:00:00.000Z, decimal: 1.12345, emptyObj: {}, nestedObject: { obj: 'test' }, notANumber: NaN, number: 1, string: 'string', undefined: undefined } }`,
-			],
-			[
-				{ deeper: { deep: everyType } },
-				`{ deeper: { deep: { boolean: true, date: 2020-01-01T00:00:00.000Z, decimal: 1.12345, emptyObj: {}, nestedObject: { obj: 'test' }, notANumber: NaN, number: 1, string: 'string', undefined: undefined } } }`,
-			],
-		])('%#. should compare %j and sort with result %j', (value, expected) => {
-			expect(objectUtil.deepStringify(value, { isSorted: true })).toEqual(expected)
-		})
-
-		it.each([
-			[{ b: 2, a: 1 }, `{ a: 1, b: 2 }`],
-			[
-				everyType,
-				`{ boolean: true, date: 2020-01-01T00:00:00.000Z, decimal: 1.12345, emptyObj: {}, nestedObject: { obj: 'test' }, notANumber: NaN, number: 1, string: 'string', undefined: undefined }`,
-			],
-			[
-				{ deep: everyType },
-				`{ deep: { boolean: true, date: 2020-01-01T00:00:00.000Z, decimal: 1.12345, emptyObj: {}, nestedObject: { obj: 'test' }, notANumber: NaN, number: 1, string: 'string', undefined: undefined } }`,
-			],
-			[
-				{ deeper: { deep: everyType } },
-				`{ deeper: { deep: { boolean: true, date: 2020-01-01T00:00:00.000Z, decimal: 1.12345, emptyObj: {}, nestedObject: { obj: 'test' }, notANumber: NaN, number: 1, string: 'string', undefined: undefined } } }`,
-			],
-		])('%#. should compare %j with result %j and not be equal because it is not sorted', (value, expected) => {
-			expect(objectUtil.deepStringify(value, { isSorted: true })).toEqual(expected)
-			expect(objectUtil.deepStringify(value)).not.toEqual(expected)
-		})
-
-		it.each([
-			[null, 'null'],
-			[undefined, 'undefined'],
-			[123, '123'],
-			[[123], `[ 123 ]`],
-			['test', "'test'"],
-			(() => {
-				const date = new Date()
-
-				return [date, date.toISOString()]
-			})(),
-		])('%#. should compare %j with result %j with compact enabled', (value, expected) => {
-			expect(objectUtil.deepStringify(value)).toEqual(expected)
-		})
-
-		it.each([
-			[['d', 'c', 'b', 'a'], `[ 'a', 'b', 'c', 'd' ]`, `[ 'd', 'c', 'b', 'a' ]`],
-			[{ a: ['d', 'c', 'b', 'a'] }, `{ a: [ 'a', 'b', 'c', 'd' ]`, `{ a: [ 'd', 'c', 'b', 'a' ] }`],
-		])('%# should not sort arrays', (arr, expectSorted, expectUnsorted) => {
-			expect(objectUtil.deepStringify(arr, { isSorted: true })).not.toEqual(expectSorted)
-			expect(objectUtil.deepStringify(arr, { isSorted: true })).toEqual(expectUnsorted)
-		})
-
-		it.each([
-			[
-				0,
-				`{
-  a: {
-    a1: {
-      a2: {
-        a3: {
-          a4: {
-            a5: 'level 5'
-          }
-        }
-      }
-    }
-  },
-  b: {
-    b1: {
-      b2: {
-        b3: {
-          b4: 'level 4'
-        }
-      }
-    }
-  },
-  c: [
-    'c0',
-    [
-      'c1',
-      [
-        'c2',
-        [
-          'c3',
-          [
-            'c4',
-            [
-              'c5'
-            ]
-          ]
-        ]
-      ]
-    ]
-  ]
-}`,
-			],
-			[
-				1,
-				`{
-  a: {
-    a1: {
-      a2: {
-        a3: {
-          a4: { a5: 'level 5' }
-        }
-      }
-    }
-  },
-  b: {
-    b1: {
-      b2: {
-        b3: { b4: 'level 4' }
-      }
-    }
-  },
-  c: [
-    'c0',
-    [
-      'c1',
-      [
-        'c2',
-        [
-          'c3',
-          [
-            'c4',
-            [ 'c5' ]
-          ]
-        ]
-      ]
-    ]
-  ]
-}`,
-			],
-			[
-				2,
-				`{
-  a: {
-    a1: {
-      a2: {
-        a3: { a4: { a5: 'level 5' } }
-      }
-    }
-  },
-  b: {
-    b1: {
-      b2: { b3: { b4: 'level 4' } }
-    }
-  },
-  c: [
-    'c0',
-    [
-      'c1',
-      [
-        'c2',
-        [
-          'c3',
-          [ 'c4', [ 'c5' ] ]
-        ]
-      ]
-    ]
-  ]
-}`,
-			],
-			[
-				3,
-				`{
-  a: {
-    a1: {
-      a2: { a3: { a4: { a5: 'level 5' } } }
-    }
-  },
-  b: {
-    b1: { b2: { b3: { b4: 'level 4' } } }
-  },
-  c: [
-    'c0',
-    [
-      'c1',
-      [
-        'c2',
-        [ 'c3', [ 'c4', [ 'c5' ] ] ]
-      ]
-    ]
-  ]
-}`,
-			],
-			[
-				4,
-				`{
-  a: {
-    a1: { a2: { a3: { a4: { a5: 'level 5' } } } }
-  },
-  b: { b1: { b2: { b3: { b4: 'level 4' } } } },
-  c: [
-    'c0',
-    [
-      'c1',
-      [ 'c2', [ 'c3', [ 'c4', [ 'c5' ] ] ] ]
-    ]
-  ]
-}`,
-			],
-			[
-				5,
-				`{
-  a: { a1: { a2: { a3: { a4: { a5: 'level 5' } } } } },
-  b: { b1: { b2: { b3: { b4: 'level 4' } } } },
-  c: [
-    'c0',
-    [ 'c1', [ 'c2', [ 'c3', [ 'c4', [ 'c5' ] ] ] ] ]
-  ]
-}`,
-			],
-			[
-				6,
-				`{
-  a: { a1: { a2: { a3: { a4: { a5: 'level 5' } } } } },
-  b: { b1: { b2: { b3: { b4: 'level 4' } } } },
-  c: [ 'c0', [ 'c1', [ 'c2', [ 'c3', [ 'c4', [ 'c5' ] ] ] ] ] ]
-}`,
-			],
-		])('%# should take object with 5 levels and compact it to level $s', (level, expected) => {
-			const obj = {
-				a: { a1: { a2: { a3: { a4: { a5: 'level 5' } } } } },
-				b: { b1: { b2: { b3: { b4: 'level 4' } } } },
-				c: ['c0', ['c1', ['c2', ['c3', ['c4', ['c5']]]]]],
-			}
-			expect(objectUtil.deepStringify(obj, { isPrettyPrinted: true, prettyPrintCompactLevel: level })).toEqual(expected)
-		})
-	})
-
-	describe('deepEqual', () => {
-		it.each([
-			[null, null],
-			[undefined, undefined],
-			[{}, {}],
-			[everyType, everyType],
-			[{ deep: everyType }, { deep: everyType }],
-			[{ deeper: { deep: everyType } }, { deeper: { deep: everyType } }],
-		])('%#. should be deep equal compare %j with result %j', (value, result) => {
-			expect(objectUtil.deepEqual(value, result)).toBeTruthy()
-		})
-
-		it.each([
-			[{}, { a: 1 }],
-			[everyType, { ...everyType, a: 1 }],
-			[{ deep: everyType }, { a: 1, deep: everyType }],
-			[{ deeper: { deep: everyType } }, { a: 1, deeper: { deep: everyType } }],
-		])('%#. should not deep equal compare %j with result %j', (value, result) => {
-			expect(objectUtil.deepEqual(value, result)).toBeFalsy()
-		})
-
-		it.each([
-			[
-				{ a: 1, b: 2 },
-				{ a: 1, b: 2 },
-			],
-			[
-				{ a: { a: 1, b: 2 }, b: everyType },
-				{ a: { a: 1, b: 2 }, b: everyTypeReversed },
-			],
-		])('%#. should be deep equal even if in different order compare %j with result %j', (value, result) => {
-			expect(objectUtil.deepEqual(value, result)).toBeTruthy()
-		})
-	})
-
-	describe('deepNullToUndefined', () => {
-		it.each([
-			[{ test: undefined }, { test: undefined }],
-			[{ test: null }, { test: undefined }],
-			[{ deep: { test: null } }, { deep: { test: undefined } }],
-			[{ deeper: { deep: { test: null } } }, { deeper: { deep: { test: undefined } } }],
-			[everyType, everyType],
-			[{ deep: everyType }, { deep: everyType }],
-			[{ deeper: { deep: everyType } }, { deeper: { deep: everyType } }],
-		])('%#. should convert null to undefined for %j', (withNulls, withUndefined) => {
-			expect(objectUtil.deepNullToUndefined(withNulls)).toEqual(withUndefined)
-		})
-	})
-})
-/* eslint-enable sort-keys-fix/sort-keys-fix */

package/src/object-util.ts

@@ -1,127 +0,0 @@
-import cloneDeep from 'lodash.clonedeep'
-import util from 'util'
-
-export type ObjectType = Record<string, any>
-
-export class ObjectUtil {
-	/**
-	 * Deep clone object. Returned object will have no references to the object passed through params
-	 * @template T
-	 * @param {T} objectToClone
-	 * @return {T}
-	 */
-	deepClone<T extends ObjectType>(objectToClone: T): T {
-		return cloneDeep(objectToClone)
-	}
-
-	/**
-	 * Pick only properties from the property list. It is only allowed to pick properties from the first level
-	 * @template T
-	 * @template L
-	 * @param {T} obj
-	 * @param {L[]} keyList
-	 * @return {Pick<T, L>}
-	 */
-	pickByList<T extends object, L extends keyof T>(obj: T, keyList: (L | string)[]): Pick<T, L> {
-		return keyList.reduce((pickedObj, key) => {
-			if (Object.prototype.hasOwnProperty.call(obj, key)) {
-				pickedObj[key as L] = obj[key as L]
-			}
-
-			return pickedObj
-		}, {} as Pick<T, L>) // eslint-disable-line @typescript-eslint/prefer-reduce-type-parameter
-	}
-
-	/**
-	 * Pick objects properties using keys from the second object.
-	 * @template T
-	 * @template L
-	 * @param {T} obj
-	 * @param {Partial<T>} objWithPickKeys
-	 * @return {Pick<T, L>}
-	 */
-	pickByObjectKeys<T extends object, L extends keyof T>(obj: T, objWithPickKeys: Partial<T> | ObjectType): Pick<T, L> {
-		const keys = Object.keys(objWithPickKeys) as L[]
-
-		return this.pickByList<T, L>(obj, keys)
-	}
-
-	/**
-	 * This function will do stringify deeper that JSON.stringify.
-	 * @param {any} entity - entity thant needs to be stringify
-	 * @param {object} [options] - available options
-	 * @param {boolean} [options.isSortable=false] - if object property should be sorted
-	 * @param {boolean} [options.isPrettyPrinted=false] - if object and array properties should be printed in a new row
-	 * @param {number} [options.prettyPrintCompactLevel=0] - if pretty print is on define the level of deepest children that are not
-	 * going to be pretty. It doesn't matter if the siblings doesn't have the same depth.
-	 * @return {string} - strung result
-	 * @example
-	 * console.log(new ObjectUtil().deepStringify(null)) // 'null'
-	 * console.log(new ObjectUtil().deepStringify(undefined)) // 'undefined'
-	 * console.log(new ObjectUtil().deepStringify({ a: 1 })) // '{\n\ta: 1\n}'
-	 * // `{
-	 * //   a:1
-	 * // }`
-	 * console.log(new ObjectUtil().deepStringify({ b: 1, a: 2 }, {isSorted:true, compact: true})) // { a: 2, b: 1 }
-	 */
-	deepStringify(
-		entity: any,
-		options?: { isSorted?: boolean; isPrettyPrinted?: boolean; prettyPrintCompactLevel?: number }
-	): string {
-		const { isSorted = false, isPrettyPrinted = false, prettyPrintCompactLevel = 0 } = options ?? {}
-
-		const compact = this._deepStringifyCompact({ isPrettyPrinted, prettyPrintCompactLevel })
-
-		return util.inspect(entity, {
-			breakLength: Infinity,
-			compact,
-			depth: Infinity,
-			maxArrayLength: Infinity,
-			maxStringLength: Infinity,
-			sorted: isSorted,
-		})
-	}
-
-	protected _deepStringifyCompact(params: { isPrettyPrinted: boolean; prettyPrintCompactLevel: number }): number | boolean {
-		const { isPrettyPrinted, prettyPrintCompactLevel } = params
-
-		if (!isPrettyPrinted) {
-			return true
-		}
-
-		return prettyPrintCompactLevel
-	}
-
-	/**
-	 * We are converting objects to string (or null or undefined) and comparing if the result is equal
-	 * @param a
-	 * @param b
-	 * @return {boolean}
-	 */
-	deepEqual(a: any, b: any): boolean {
-		return this.deepStringify(a, { isSorted: true }) === this.deepStringify(b, { isSorted: true })
-	}
-
-	/**
-	 * This function is going to convert any null to undefined in the object that is passed to it.
-	 * @template T
-	 * @param {T} objectWithNulls
-	 * @return {T}
-	 * @example
-	 * console.log(new ObjectUtil().deepNullToUndefined({ a: null, b: { c: null } })) // { a: undefined, b: { c: undefined } }
-	 */
-	deepNullToUndefined<T extends ObjectType>(objectWithNulls: T): T {
-		return Object.entries(objectWithNulls).reduce<any>((acc, cur) => {
-			const [key, value] = cur
-			if (value === null) {
-				acc[key] = undefined
-			} else if (typeof value === 'object' && !(value instanceof Date)) {
-				acc[key] = this.deepNullToUndefined(value)
-			} else {
-				acc[key] = value
-			}
-
-			return acc
-		}, {})
-	}
-}

package/src/regex-util.test.ts

@@ -1,25 +0,0 @@
-import { regexUtil } from 'src/regex-util'
-
-describe('regexUtil', () => {
-	it.each([
-		['00000000-0000-0000-0000-000000000000'],
-		['b40c3094-a238-4c21-a744-f19b9e476abf'],
-		['7d39e0a8-4ca2-41ff-9ded-312fb08f4dda'],
-		['f9ea83de-c69f-42ff-8764-a6e88d59d75d'],
-		['33f13db5-d427-4ea4-b028-6fc30a84d827'],
-		['f04ec90e-2ff5-4b88-beb3-23b348b8e33b'],
-		['83ad915b-645a-4132-b8c1-ab398701ba66'],
-		['3510e9f1-08f6-4c5a-86a9-66e91c6093b7'],
-		['02f243d8-3225-460b-9df7-30380d96971d'],
-		['f27571d4-8c4a-4c9a-8899-932d0fa7a68c'],
-		['b87a9f9c-c7c2-4aa2-85af-87221cebce9d'],
-	])('%#. should pass regex expression check %s', (uuidString) => {
-		expect(new RegExp(regexUtil.uuid).test(uuidString)).toBeTruthy()
-	})
-	it.each([['a'], ['test'], [123], [{}], [{ uuid: '3510e9f1-08f6-4c5a-86a9-66e91c6093b7' }], [new Date()]])(
-		'%#. should pass regex expression check %s',
-		(uuidString) => {
-			expect(new RegExp(regexUtil.uuid).test(uuidString.toString())).toBeFalsy()
-		}
-	)
-})

package/src/regex-util.ts

@@ -1,11 +0,0 @@
-export const regexUtil = {
-	/**
-	 * This is a UUID regex expression. This is usually used in express router to constrict the values passed as a path parameter (if you are using UUID as your identifier).
-	 * @return {string}
-	 * @example
-	 * const { uuid } = regexUtil
-	 * router.route(`/users/:userId(${uuid})`).get(getUsersById)
-	 * //...
-	 */
-	uuid: `\\b[0-9a-f]{8}\\b-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-\\b[0-9a-f]{12}\\b` as const,
-}

package/src/single-threshold-promise.test.ts

@@ -1,91 +0,0 @@
-import { SingleThresholdPromise } from 'src/single-threshold-promise'
-import { timeout } from 'src/timeout'
-
-describe('SingleThresholdPromise', () => {
-	describe('promise', () => {
-		let callCounter = 0
-		const fake_asyncFactoryFn = jest.fn()
-		const fake_asyncRejectFactoryFn = jest.fn()
-
-		beforeEach(() => {
-			callCounter = 0
-			jest.useFakeTimers()
-			fake_asyncFactoryFn.mockImplementation(async (): Promise<{ callCount: number }> => {
-				await timeout(1000)
-
-				return { callCount: ++callCounter }
-			})
-			fake_asyncRejectFactoryFn.mockImplementation(async (): Promise<{ callCount: number }> => {
-				await timeout(1000)
-				throw new Error()
-			})
-		})
-
-		afterEach(() => {
-			jest.clearAllTimers()
-			jest.useRealTimers()
-			jest.resetAllMocks()
-		})
-
-		it('should return result of the factory function when promise called', async () => {
-			const singleThresholdPromiseImplementation = new SingleThresholdPromise(fake_asyncFactoryFn)
-			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
-
-			const promise = singleThresholdPromiseImplementation.promise()
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
-			jest.runAllTimers()
-			expect(await promise).toEqual({ callCount: 1 })
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
-		})
-
-		it('should return the same promise result to multiple calls before the first promise is resolved ', async () => {
-			const expected = { callCount: 1 }
-
-			const singleThresholdPromiseImplementation = new SingleThresholdPromise(fake_asyncFactoryFn)
-			const promise1 = singleThresholdPromiseImplementation.promise()
-			const promise2 = singleThresholdPromiseImplementation.promise()
-			const promise3 = singleThresholdPromiseImplementation.promise()
-
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
-			jest.runAllTimers()
-			expect(await promise1).toEqual(expected)
-			expect(await promise2).toEqual(expected)
-			expect(await promise3).toEqual(expected)
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
-		})
-
-		it('should return different promise result to multiple calls if they are called after the promise is resolved', async () => {
-			const singleThresholdPromiseImplementation = new SingleThresholdPromise(fake_asyncFactoryFn)
-
-			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
-
-			const promise1 = singleThresholdPromiseImplementation.promise()
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
-			jest.runAllTimers()
-			expect(await promise1).toEqual({ callCount: 1 })
-
-			const promise2 = singleThresholdPromiseImplementation.promise()
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(2)
-			jest.runAllTimers()
-			expect(await promise2).toEqual({ callCount: 2 })
-
-			const promise3 = singleThresholdPromiseImplementation.promise()
-			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(3)
-			jest.runAllTimers()
-			expect(await promise3).toEqual({ callCount: 3 })
-		})
-
-		it('should reject all if promise is rejected', async () => {
-			const singleThresholdPromiseImplementation = new SingleThresholdPromise(fake_asyncRejectFactoryFn)
-			const promise1 = singleThresholdPromiseImplementation.promise()
-			const promise2 = singleThresholdPromiseImplementation.promise()
-			const promise3 = singleThresholdPromiseImplementation.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)
-			await promise3.then(() => expect.fail('test failed')).catch(() => undefined)
-			expect(fake_asyncRejectFactoryFn).toHaveBeenCalledTimes(1)
-		})
-	})
-})

package/src/single-threshold-promise.ts

@@ -1,56 +0,0 @@
-import { AnyFunctionPromiseNoParams } from 'src/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 class SingleThresholdPromise<T> {
-	protected _cache: {
-		promises?: { resolve: (value: T | PromiseLike<T>) => void; reject: (reason?: any) => void }[]
-	} = {}
-
-	protected _factoryFn: AnyFunctionPromiseNoParams<T>
-
-	constructor(factoryFn: AnyFunctionPromiseNoParams<T>) {
-		this._factoryFn = factoryFn
-	}
-
-	protected _rejectPromises(): void {
-		if (this._cache.promises) {
-			this._cache.promises.forEach((promise) => promise.reject(new Error('Cache was cleaned')))
-		}
-		delete this._cache.promises
-	}
-
-	async promise(): Promise<T> {
-		if ('promises' in this._cache) {
-			return new Promise<T>((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
-	}
-}