assertron 11.2.0 → 11.2.1

package/ts/assertron/isInstanceof.ts

@@ -1,8 +1,11 @@
 import type { AnyConstructor } from 'type-plus'
 import { AssertionError } from '../errors.js'
 
-export function isInstanceof<T extends AnyConstructor>(value: unknown, type: T): asserts value is InstanceType<T> {
-  if (value instanceof type) return
+export function isInstanceof<T extends AnyConstructor>(
+	value: unknown,
+	type: T
+): asserts value is InstanceType<T> {
+	if (value instanceof type) return
 
-  throw new AssertionError(`Expected ${value} to be an instance of ${type.name}`, { ssf: isInstanceof })
+	throw new AssertionError(`Expected ${value} to be an instance of ${type.name}`, { ssf: isInstanceof })
 }

package/ts/assertron/pathEqual.ts

@@ -3,6 +3,6 @@ import { AssertionError } from '../errors.js'
 import { notEqualMessage } from '../utils/index.js'
 
 export function pathEqual(actual: string, expected: string) {
-  if (!isPathEqual(actual, expected))
-    throw new AssertionError(notEqualMessage(actual, expected), { ssf: pathEqual })
+	if (!isPathEqual(actual, expected))
+		throw new AssertionError(notEqualMessage(actual, expected), { ssf: pathEqual })
 }

package/ts/assertron/rejects.ts

@@ -2,8 +2,10 @@ import { AssertionError } from '../errors.js'
 import { notRejectedMessage } from '../utils/index.js'
 
 export function rejects<R = any>(promise: Promise<any>): Promise<R> {
-  return promise.then(
-    value => { throw new AssertionError(notRejectedMessage(value), { ssf: rejects }) },
-    err => err
-  )
+	return promise.then(
+		value => {
+			throw new AssertionError(notRejectedMessage(value), { ssf: rejects })
+		},
+		err => err
+	)
 }

package/ts/assertron/repeat.ts

@@ -5,28 +5,34 @@ import { FailOnOccurrence } from '../errors.js'
  * Repeat the specified function n times and return the last result.
  * If the result is a promise, it will run the function sequentially.
  */
-export function repeat<R>(fn: () => R | (() => Promise<R>), times: number): ReturnType<typeof fn> extends Promise<R> ? Promise<R> : R {
-  return repeatRecur(fn, 1, times)
+export function repeat<R>(
+	fn: () => R | (() => Promise<R>),
+	times: number
+): ReturnType<typeof fn> extends Promise<R> ? Promise<R> : R {
+	return repeatRecur(fn, 1, times)
 }
 
-function repeatRecur<R>(fn: () => R | (() => Promise<R>), i: number, times: number): ReturnType<typeof fn> extends Promise<R> ? Promise<R> : R {
-  try {
-    const result = fn()
-    if (i === times) return result as any
+function repeatRecur<R>(
+	fn: () => R | (() => Promise<R>),
+	i: number,
+	times: number
+): ReturnType<typeof fn> extends Promise<R> ? Promise<R> : R {
+	try {
+		const result = fn()
+		if (i === times) return result as any
 
-    if (isPromise(result)) {
-      return result.then(
-        () => repeatRecur(fn, i + 1, times),
-        (e) => { throw new FailOnOccurrence(i, e, { ssf: repeat }) }
-      ) as any
-    }
-    else {
-      return repeatRecur(fn, i + 1, times)
-    }
-  }
-  catch (e) {
-    if (e instanceof FailOnOccurrence) throw e
-    throw new FailOnOccurrence(i, e, { ssf: repeat })
-  }
+		if (isPromise(result)) {
+			return result.then(
+				() => repeatRecur(fn, i + 1, times),
+				e => {
+					throw new FailOnOccurrence(i, e, { ssf: repeat })
+				}
+			) as any
+		} else {
+			return repeatRecur(fn, i + 1, times)
+		}
+	} catch (e) {
+		if (e instanceof FailOnOccurrence) throw e
+		throw new FailOnOccurrence(i, e, { ssf: repeat })
+	}
 }
-

package/ts/assertron/resolves.ts

@@ -2,8 +2,10 @@ import { AssertionError } from '../errors.js'
 import { notResolvedMessage } from '../utils/index.js'
 
 export function resolves(promise: Promise<any>) {
-  return promise.then(
-    () => { },
-    error => { throw new AssertionError(notResolvedMessage(error), { ssf: resolves }) }
-  )
+	return promise.then(
+		() => {},
+		error => {
+			throw new AssertionError(notResolvedMessage(error), { ssf: resolves })
+		}
+	)
 }

package/ts/assertron/satisfies.ts

@@ -3,30 +3,37 @@ import type { If, IsExtend, NonComposableTypes } from 'type-plus'
 import { AssertionError } from '../errors.js'
 import { notSatisfiedMessage } from '../utils/index.js'
 
-export type SatisfyExpectation<T> = If<
-  IsExtend<T, string>,
-  T | RegExp,
-  If<
-    IsExtend<T, NonComposableTypes>,
-    T,
-    If<IsExtend<T, Array<any>>,
-      T extends Array<infer E> ? Array<SatisfyExpectation<E>> : never,
-      {
-        [P in keyof T]?: T[P] extends string
-        ? SatisfyExpectation<T[P]> | RegExp
-        : SatisfyExpectation<T[P]>
-      }
-    >>
-> | ((v: T) => boolean)
+export type SatisfyExpectation<T> =
+	| If<
+			IsExtend<T, string>,
+			T | RegExp,
+			If<
+				IsExtend<T, NonComposableTypes>,
+				T,
+				If<
+					IsExtend<T, Array<any>>,
+					T extends Array<infer E> ? Array<SatisfyExpectation<E>> : never,
+					{
+						[P in keyof T]?: T[P] extends string
+							? SatisfyExpectation<T[P]> | RegExp
+							: SatisfyExpectation<T[P]>
+					}
+				>
+			>
+	  >
+	| ((v: T) => boolean)
 
 /**
  * Check if `actual` satisfies criteria in `expected`.
  * @param expected All properties can be a value which will be compared to the same property in `actual`,
  * RegExp, or a predicate function that will be used to check against the property.
  */
-export function satisfies<Actual, Expected extends Actual>(actual: Actual, expected: SatisfyExpectation<Expected>) {
-  const diff = createSatisfier(expected as any).exec(actual)
-  if (diff) {
-    throw new AssertionError(notSatisfiedMessage(diff), { ssf: satisfies })
-  }
+export function satisfies<Actual, Expected extends Actual>(
+	actual: Actual,
+	expected: SatisfyExpectation<Expected>
+) {
+	const diff = createSatisfier(expected as any).exec(actual)
+	if (diff) {
+		throw new AssertionError(notSatisfiedMessage(diff), { ssf: satisfies })
+	}
 }

package/ts/assertron/throws.ts

@@ -1,67 +1,88 @@
 import isPromise from 'is-promise'
 import { AssertionError } from '../errors.js'
 import type { ErrorConstructor, ErrorValidator } from '../types.js'
-import { isErrorConstructor, notRejectedMessage, notThrownMessage, unexpectedErrorMessage } from '../utils/index.js'
+import {
+	isErrorConstructor,
+	notRejectedMessage,
+	notThrownMessage,
+	unexpectedErrorMessage
+} from '../utils/index.js'
 
-export function throws<E extends Error>(value: PromiseLike<any>, error?: ErrorValidator | ErrorConstructor<E>): Promise<E>
-export function throws<E extends Error>(value: (...args: any[]) => never, error?: ErrorValidator | ErrorConstructor<E>): E
-export function throws<E extends Error, R = any>(value: (...args: any[]) => R, error?: ErrorValidator | ErrorConstructor<E>): R extends Promise<any> ? Promise<E> : E
-export function throws<T, R = any>(value: (...args: any[]) => R, validator?: ErrorValidator): R extends Promise<any> ? Promise<T> : T
-export function throws(value: PromiseLike<any> | (() => any | PromiseLike<any>), validator?: ErrorValidator | ErrorConstructor<any>): any {
-  if (typeof value !== 'function' && !isPromise(value)) {
-    throw new AssertionError(
-      '`assertron.throws()` must be called with a function or promise.',
-      { ssf: throws }
-    )
-  }
+export function throws<E extends Error>(
+	value: PromiseLike<any>,
+	error?: ErrorValidator | ErrorConstructor<E>
+): Promise<E>
+export function throws<E extends Error>(
+	value: (...args: any[]) => never,
+	error?: ErrorValidator | ErrorConstructor<E>
+): E
+export function throws<E extends Error, R = any>(
+	value: (...args: any[]) => R,
+	error?: ErrorValidator | ErrorConstructor<E>
+): R extends Promise<any> ? Promise<E> : E
+export function throws<T, R = any>(
+	value: (...args: any[]) => R,
+	validator?: ErrorValidator
+): R extends Promise<any> ? Promise<T> : T
+export function throws(
+	value: PromiseLike<any> | (() => any | PromiseLike<any>),
+	validator?: ErrorValidator | ErrorConstructor<any>
+): any {
+	if (typeof value !== 'function' && !isPromise(value)) {
+		throw new AssertionError('`assertron.throws()` must be called with a function or promise.', {
+			ssf: throws
+		})
+	}
 
-  if (!isPromise(value)) {
-    const { threw, err, result } = tryCatch(value)
-    if (threw) {
-      if (failValidation(validator, err)) {
-        throw new AssertionError(unexpectedErrorMessage(err, validator), { ssf: throws })
-      }
-      return err
-    }
-    value = result
-  }
+	if (!isPromise(value)) {
+		const { threw, err, result } = tryCatch(value)
+		if (threw) {
+			if (failValidation(validator, err)) {
+				throw new AssertionError(unexpectedErrorMessage(err, validator), { ssf: throws })
+			}
+			return err
+		}
+		value = result
+	}
 
-  if (isPromise(value)) {
-    return value.then(
-      value => { throw new AssertionError(notRejectedMessage(value), { ssf: throws }) },
-      err => {
-        if (failValidation(validator, err)) {
-          throw new AssertionError(unexpectedErrorMessage(err, validator), { ssf: throws })
-        }
-        return err
-      }
-    )
-  }
+	if (isPromise(value)) {
+		return value.then(
+			value => {
+				throw new AssertionError(notRejectedMessage(value), { ssf: throws })
+			},
+			err => {
+				if (failValidation(validator, err)) {
+					throw new AssertionError(unexpectedErrorMessage(err, validator), { ssf: throws, cause: err })
+				}
+				return err
+			}
+		)
+	}
 
-  throw new AssertionError(notThrownMessage(value), { ssf: throws })
+	throw new AssertionError(notThrownMessage(value), { ssf: throws })
 }
 
 function tryCatch(fn: () => any) {
-  let result
-  let err
-  let threw = false
-  try {
-    result = fn()
-  }
-  catch (e) {
-    err = e
-    threw = true
-  }
-  return { threw, err, result }
+	let result
+	let err
+	let threw = false
+	try {
+		result = fn()
+	} catch (e) {
+		err = e
+		threw = true
+	}
+	return { threw, err, result }
 }
-function failValidation(validator: ErrorValidator | ErrorConstructor<any> | undefined, error: any): validator is ErrorValidator | ErrorConstructor<any> {
-  if (!validator) return false
+function failValidation(
+	validator: ErrorValidator | ErrorConstructor<any> | undefined,
+	error: any
+): validator is ErrorValidator | ErrorConstructor<any> {
+	if (!validator) return false
 
-  if (isErrorConstructor(validator)) {
-    return !(error instanceof validator)
-  }
-  else {
-    return !validator(error)
-  }
+	if (isErrorConstructor(validator)) {
+		return !(error instanceof validator)
+	} else {
+		return !validator(error)
+	}
 }
-

package/ts/assertron/truthy.ts

@@ -1,8 +1,5 @@
 import { AssertionError } from '../errors.js'
 
 export function truthy(value: unknown) {
-  if (!value) throw new AssertionError(
-    `Expected value to be truthy, but received ${value}`,
-    { ssf: truthy }
-  )
+	if (!value) throw new AssertionError(`Expected value to be truthy, but received ${value}`, { ssf: truthy })
 }

package/ts/errors.ts

@@ -6,17 +6,17 @@ import { failOnOccurrence } from './utils/index.js'
  * A base error for all assertion errors
  */
 export class AssertionError extends ModuleError {
-  constructor(message: string, options: AssertionError.Options) {
-    super('assertron', message, options)
-  }
+	constructor(message: string, options: AssertionError.Options) {
+		super('assertron', message, options)
+	}
 }
 
 export namespace AssertionError {
-  export type Options = RequiredPick<ModuleError.Options, 'ssf'>
+	export type Options = RequiredPick<ModuleError.Options, 'ssf'>
 }
 
 export class FailOnOccurrence extends AssertionError {
-  constructor(public occurrence: number, public error: any, options: AssertionError.Options) {
-    super(failOnOccurrence(occurrence, error), options)
-  }
+	constructor(public occurrence: number, public error: any, options: AssertionError.Options) {
+		super(failOnOccurrence(occurrence, error), options)
+	}
 }

package/ts/testUtils.ts

@@ -7,78 +7,75 @@ import type { ErrorConstructor } from './types.js'
 export type AnyFunction = (...args: any[]) => any
 
 export function runAsync(fn: AnyFunction) {
-  return new Promise((resolve, reject) => {
-    setTimeout(() => {
-      try {
-        resolve(fn())
-      }
-      catch (err) {
-        reject(err)
-      }
-    }, 1)
-  })
+	return new Promise((resolve, reject) => {
+		setTimeout(() => {
+			try {
+				resolve(fn())
+			} catch (err) {
+				reject(err)
+			}
+		}, 1)
+	})
 }
 
 export function runSequentialAsync(...fns: AnyFunction[]) {
-  return new Promise((resolve, reject) => {
-    setTimeout(() => {
-      try {
-        let i = 0
-        for (; i < fns.length - 1; i++) {
-          fns[i]()
-        }
-        resolve(fns[i]())
-      }
-      catch (err) {
-        reject(err)
-      }
-    }, 1)
-  })
+	return new Promise((resolve, reject) => {
+		setTimeout(() => {
+			try {
+				let i = 0
+				for (; i < fns.length - 1; i++) {
+					fns[i]()
+				}
+				resolve(fns[i]())
+			} catch (err) {
+				reject(err)
+			}
+		}, 1)
+	})
 }
 
 export function runParallelAsync(...fns: AnyFunction[]) {
-  return Promise.all(fns.map(fn => runAsync(fn)))
+	return Promise.all(fns.map(fn => runAsync(fn)))
 }
 
-
 export function assertIsPromise(promiseError: Promise<any>) {
-  t(isPromise(promiseError))
+	t(isPromise(promiseError))
 }
 
 export function assertIsError(err: Error) {
-  t(isError(err))
+	t(isError(err))
 }
 
 export function assertThrows<E extends Error>(fn: AnyFunction, ErrorType?: ErrorConstructor<E>): E {
-  try {
-    fn()
-  }
-  catch (e: any) {
-    if (ErrorType && !(e instanceof ErrorType)) {
-      throw new Error(`thrown error ${e} is not of expected type ${ErrorType}`)
-    }
-    return e
-  }
-  throw new Error(`${fn} does not throw as expected`)
+	try {
+		fn()
+	} catch (e: any) {
+		if (ErrorType && !(e instanceof ErrorType)) {
+			throw new Error(`thrown error ${e} is not of expected type ${ErrorType}`)
+		}
+		return e
+	}
+	throw new Error(`${fn} does not throw as expected`)
 }
 
-export async function assertAsyncThrows<E extends Error>(fn: AnyFunction, ErrorType?: ErrorConstructor<E>): Promise<E> {
-  try {
-    await fn()
-  }
-  catch (e: any) {
-    // console.log('catch clause', e)
-    if (ErrorType && !(e instanceof ErrorType)) {
-      throw new Error(`thrown error ${e} is not of expected type ${ErrorType}`)
-    }
-    // console.log('returning e')
-    return e
-  }
-  throw new Error(`${fn} does not throw as expected`)
+export async function assertAsyncThrows<E extends Error>(
+	fn: AnyFunction,
+	ErrorType?: ErrorConstructor<E>
+): Promise<E> {
+	try {
+		await fn()
+	} catch (e: any) {
+		// console.log('catch clause', e)
+		if (ErrorType && !(e instanceof ErrorType)) {
+			throw new Error(`thrown error ${e} is not of expected type ${ErrorType}`)
+		}
+		// console.log('returning e')
+		return e
+	}
+	throw new Error(`${fn} does not throw as expected`)
 }
 
-
 export function noStackTraceFor(filename: string, err: Error) {
-  if (err.stack && RegExp(escapeRegExp(filename)).test(err.stack))
-    throw new Error(`contains internal stack: \n${err.stack}`)
+	if (err.stack && RegExp(escapeRegExp(filename)).test(err.stack))
+		throw new Error(`contains internal stack: \n${err.stack}`)
 }

package/ts/types.ts

@@ -1,3 +1,2 @@
-
 export type ErrorValidator = (value: any) => boolean
 export type ErrorConstructor<E extends Error> = new (...args: any[]) => E

package/ts/utils/index.ts

@@ -8,5 +8,5 @@ export * from './promiseMessages.js'
 export * from './unexpectedErrorMessage.js'
 
 export function failOnOccurrence(occurrence: number, error: any) {
-  return `Failed on ${occurrence} occurrence: ${tersify(error, { maxLength: Infinity })}`
+	return `Failed on ${occurrence} occurrence: ${tersify(error, { maxLength: Infinity })}`
 }

package/ts/utils/isErrorConstructor.ts

@@ -1,5 +1,5 @@
 import type { ErrorConstructor } from '../types.js'
 
 export function isErrorConstructor(validator: any): validator is ErrorConstructor<any> {
-  return Object.prototype.isPrototypeOf.call(Error.prototype, validator.prototype)
+	return Object.prototype.isPrototypeOf.call(Error.prototype, validator.prototype)
 }

package/ts/utils/notEqualMessage.ts

@@ -1,3 +1,3 @@
 export function notEqualMessage(actual: any, expected: any) {
-  return `Expected value to equal ${expected}, but received ${actual}`
+	return `Expected value to equal ${expected}, but received ${actual}`
 }

package/ts/utils/notSatisfiedMessage.ts

@@ -2,26 +2,30 @@ import type { Diff } from 'satisfier'
 import { tersify } from 'tersify'
 
 export function notSatisfiedMessage(entries: Diff[]) {
-  return entries.map(e => {
-    const path = formatPath(e.path)
-    return `Expect ${path} to satisfy ${formatValue(e.expected)}, but received ${formatValue(e.actual)}`
-  }).join('\n')
+	return entries
+		.map(e => {
+			const path = formatPath(e.path)
+			return `Expect ${path} to satisfy ${formatValue(e.expected)}, but received ${formatValue(e.actual)}`
+		})
+		.join('\n')
 }
 
 function formatPath(entries: (string | number)[]) {
-  if (entries.length === 0)
-    return 'actual'
-  const nodes = [...entries]
-  if (isIndice(nodes[0])) {
-    nodes.unshift('actual')
-  }
-  return nodes.map(n => isIndice(n) ? `[${n}]` : '.' + n).join('').slice(1)
+	if (entries.length === 0) return 'actual'
+	const nodes = [...entries]
+	if (isIndice(nodes[0])) {
+		nodes.unshift('actual')
+	}
+	return nodes
+		.map(n => (isIndice(n) ? `[${n}]` : '.' + n))
+		.join('')
+		.slice(1)
 }
 
 function isIndice(node: string | number): node is number {
-  return typeof node === 'number'
+	return typeof node === 'number'
 }
 
 function formatValue(value: any) {
-  return tersify(value)
+	return tersify(value)
 }

package/ts/utils/notThrownMessage.ts

@@ -1,5 +1,5 @@
 import { tersify } from 'tersify'
 
 export function notThrownMessage(value: any) {
-  return `Expect function to throw, but it returned '${tersify(value)}' instead.`
+	return `Expect function to throw, but it returned '${tersify(value)}' instead.`
 }

package/ts/utils/promiseMessages.ts

@@ -1,12 +1,19 @@
 import { tersify } from 'tersify'
 
 export function notRejectedMessage(value: any) {
-  return `Expected promise to reject, but it resolves with ` + (typeof value === 'string'
-    ? `'${value}'` : tersify(value, { maxLength: Infinity }))
+	return (
+		`Expected promise to reject, but it resolves with ` +
+		(typeof value === 'string' ? `'${value}'` : tersify(value, { maxLength: Infinity }))
+	)
 }
 
 export function notResolvedMessage(error: any) {
-  return `Expected promise to resolve, but it rejects with ` + (typeof error === 'string'
-    ? `'${error}'` : error instanceof Error ? error : tersify(error, { maxLength: Infinity }))
+	return (
+		`Expected promise to resolve, but it rejects with ` +
+		(typeof error === 'string'
+			? `'${error}'`
+			: error instanceof Error
+			? error
+			: tersify(error, { maxLength: Infinity }))
+	)
 }
-

package/ts/utils/unexpectedErrorMessage.ts

@@ -3,6 +3,7 @@ import type { ErrorConstructor, ErrorValidator } from '../types.js'
 import { isErrorConstructor } from './isErrorConstructor.js'
 
 export function unexpectedErrorMessage(actual: any, expected: ErrorValidator | ErrorConstructor<any>) {
-  return `Unexpected error. Expecting '${isErrorConstructor(expected) ?
-    expected.name : tersify(expected)}' but received ${tersify(actual)}`
+	return `Unexpected error. Expecting '${
+		isErrorConstructor(expected) ? expected.name : tersify(expected)
+	}' but received ${tersify(actual)}`
 }