assertron 10.0.1 → 10.4.0

package/ts/assertron/truthy.ts

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

package/ts/errors.ts

@@ -1,22 +1,22 @@
-import { IsoError, ModuleError } from 'iso-error'
-import { RequiredPick } from 'type-plus'
+import { ModuleError } from 'iso-error'
+import type { RequiredPick } from 'type-plus'
 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<IsoError.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/index.ts

@@ -1,7 +1,23 @@
 import { assertron } from './assertron/index.js'
 
+export {
+	anything,
+	has,
+	every,
+	hasAll,
+	isInClosedInterval,
+	isInLeftClosedInterval,
+	isInOpenInterval,
+	isInRange,
+	isInRightClosedInterval,
+	isTypeOf,
+	none,
+	some,
+	startsWith
+} from 'satisfier'
 export * from './assert-order/index.js'
 export * from './assertron/index.js'
 export * from './errors.js'
-export default assertron
 export { assertron as a }
+
+export default assertron

package/ts/testUtils.ts

@@ -2,83 +2,80 @@
 import t from 'assert'
 import isPromise from 'is-promise'
 import { escapeRegExp, isError } from 'lodash'
-import { ErrorConstructor } from './types.js'
+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 { ErrorConstructor } from '../types.js'
+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

@@ -1,27 +1,31 @@
-import { Diff } from 'satisfier'
+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

@@ -1,8 +1,9 @@
 import { tersify } from 'tersify'
-import { ErrorConstructor, ErrorValidator } from '../types.js'
+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)}`
 }