assertron 11.1.4 → 11.2.1

package/ts/assert-order/StateMachine.ts

@@ -1,96 +1,103 @@
 import * as perf from 'perf_hooks'
-import { State } from './types.js'
+import type { State } from './types.js'
 
-let timeTracker: { start(): void, taken(): number }
-// istanbul ignore else
-if (process && typeof process.hrtime === 'function') {
-  let tick: [number, number]
-  timeTracker = {
-    start() { tick = process.hrtime() },
-    taken() {
-      const [second, nanoSecond] = process.hrtime(tick)
-      return second * 1000 + nanoSecond / 1e6
-    }
-  }
-}
-else if (perf.performance && typeof perf.performance.now === 'function') {
-  const now = perf.performance.now
-  let tick: number
-  timeTracker = {
-    start() { tick = now() },
-    taken() { return now() - tick }
-  }
-}
-else {
-  let tick: number
-  timeTracker = {
-    start() { tick = new Date().valueOf() },
-    taken() { return new Date().valueOf() - tick }
-  }
+let timeTracker: { start(): void; taken(): number }
+
+if (global['process'] && typeof global['process'].hrtime === 'function') {
+	let tick: [number, number]
+	timeTracker = {
+		start() {
+			tick = global['process'].hrtime()
+		},
+		taken() {
+			const [second, nanoSecond] = global['process'].hrtime(tick)
+			return second * 1000 + nanoSecond / 1e6
+		}
+	}
+} else if (perf.performance && typeof perf.performance.now === 'function') {
+	const now = perf.performance.now
+	let tick: number
+	timeTracker = {
+		start() {
+			tick = now()
+		},
+		taken() {
+			return now() - tick
+		}
+	}
+} else {
+	let tick: number
+	timeTracker = {
+		start() {
+			tick = new Date().valueOf()
+		},
+		taken() {
+			return new Date().valueOf() - tick
+		}
+	}
 }
 
 export class StateMachine {
-  listeners: Record<number, Array<() => void>> = {}
-  step = 1
-  maxStep?: number
+	listeners: Record<number, Array<() => void>> = {}
+	step = 1
+	maxStep?: number
 
-  subStep = 0
-  minSubStep?: number
-  maxSubStep?: number
-  constructor(maxStep?: number) {
-    this.maxStep = maxStep
-    timeTracker.start()
-  }
-  jump(step: number) {
-    this.step = step
-    this.subStep = 0
-    return this.step
-  }
-  move() {
-    const listeners = this.listeners[this.step]
-    this.step = this.step + 1
-    this.subStep = 0
-    if (listeners) {
-      listeners.forEach(l => l())
-    }
-    return this.step
-  }
-  moveSubStep() {
-    const subStep = ++this.subStep
-    if (this.maxSubStep === this.subStep)
-      this.move()
-    return subStep
-  }
-  get(): State {
-    const { step, subStep, maxStep, minSubStep, maxSubStep } = this
-    return {
-      step,
-      maxStep,
-      subStep,
-      minSubStep,
-      maxSubStep
-    }
-  }
-  on(step: number, listener: () => void) {
-    this.listeners[step] = [listener]
-  }
-  isNotValid(step: number) {
-    return step !== this.step || (this.maxStep !== undefined && this.maxStep < step)
-  }
-  isValid(step: number) {
-    return step === this.step
-  }
-  isMaxStepDefined() {
-    return this.maxStep !== undefined
-  }
-  stopAccepting() {
-    this.maxStep = this.step - 1
-  }
-  isAccepting() {
-    // istanbul ignore next
-    return this.maxStep ? this.maxStep >= this.step : true
-  }
-  getTimeTaken() {
-    return timeTracker.taken()
-  }
+	subStep = 0
+	minSubStep?: number
+	maxSubStep?: number
+	constructor(maxStep?: number) {
+		this.maxStep = maxStep
+		timeTracker.start()
+	}
+	jump(step: number) {
+		this.step = step
+		this.subStep = 0
+		return this.step
+	}
+	move() {
+		const listeners = this.listeners[this.step]
+		this.step = this.step + 1
+		this.subStep = 0
+		if (listeners) {
+			listeners.forEach(l => l())
+		}
+		return this.step
+	}
+	moveSubStep() {
+		const subStep = ++this.subStep
+		if (this.maxSubStep === this.subStep) this.move()
+		return subStep
+	}
+	get(): State {
+		const { step, subStep, maxStep, minSubStep, maxSubStep } = this
+		return {
+			step,
+			maxStep,
+			subStep,
+			minSubStep,
+			maxSubStep
+		}
+	}
+	on(step: number, listener: () => void) {
+		this.listeners[step] = [listener]
+	}
+	isNotValid(step: number) {
+		return step !== this.step || (this.maxStep !== undefined && this.maxStep < step)
+	}
+	isValid(step: number) {
+		return step === this.step
+	}
+	isMaxStepDefined() {
+		return this.maxStep !== undefined
+	}
+	stopAccepting() {
+		this.maxStep = this.step - 1
+	}
+	isAccepting() {
+		// istanbul ignore next
+		return this.maxStep ? this.maxStep >= this.step : true
+	}
+	getTimeTaken() {
+		return timeTracker.taken()
+	}
 }

package/ts/assert-order/index.ts

@@ -1,4 +1,3 @@
 export * from './AssertOrder.js'
 export * from './InvalidOrder.js'
 export * from './types.js'
-

package/ts/assert-order/internalInterfaces.ts

@@ -1,5 +1,5 @@
 export interface Steps {
-  once?: number[],
-  some?: number[],
-  all?: number[],
+	once?: number[]
+	some?: number[]
+	all?: number[]
 }

package/ts/assert-order/types.ts

@@ -1,7 +1,7 @@
 export interface State {
-  step: number,
-  maxStep?: number,
-  subStep: number,
-  minSubStep?: number,
-  maxSubStep?: number,
+	step: number
+	maxStep?: number
+	subStep: number
+	minSubStep?: number
+	maxSubStep?: number
 }

package/ts/assertron/assertron.ts

@@ -8,43 +8,50 @@ import { pathEqual } from './pathEqual.js'
 import { rejects } from './rejects.js'
 import { repeat } from './repeat.js'
 import { resolves } from './resolves.js'
-import { satisfies, SatisfyExpectation } from './satisfies.js'
+import { satisfies, type SatisfyExpectation } from './satisfies.js'
 import { throws } from './throws.js'
 import { truthy } from './truthy.js'
 
 export type Assertron = {
-  false(value: unknown): asserts value is false,
-  falsy(value: any): asserts value is false | 0 | '' | null | undefined,
-  isInstanceof<T extends AnyConstructor>(value: unknown, type: T): asserts value is InstanceType<T>,
-  pathEqual(actual: string, expected: string): void,
-  rejects<R = any>(promise: Promise<any>): Promise<R>,
-  repeat<R>(fn: () => R | (() => Promise<R>), times: number): ReturnType<typeof fn> extends Promise<R> ? Promise<R> : R,
-  resolves(promise: Promise<any>): Promise<void>,
-  satisfies<Actual, Expected extends Actual>(actual: Actual, expected: SatisfyExpectation<Expected>): void,
-  throws<E extends Error>(value: PromiseLike<any>, error?: ErrorValidator | ErrorConstructor<E>): Promise<E>,
-  throws<E extends Error>(value: (...args: any[]) => never, error?: ErrorValidator | ErrorConstructor<E>): E,
-  throws<E extends Error, R = any>(value: (...args: any[]) => R, error?: ErrorValidator | ErrorConstructor<E>): R extends Promise<any> ? Promise<E> : E,
-  throws<T, R = any>(value: (...args: any[]) => R, validator?: ErrorValidator): R extends Promise<any> ? Promise<T> : T,
-  true(value: any): asserts value is true,
-  truthy(value: unknown): void
+	false(value: unknown): asserts value is false
+	falsy(value: any): asserts value is false | 0 | '' | null | undefined
+	isInstanceof<T extends AnyConstructor>(value: unknown, type: T): asserts value is InstanceType<T>
+	pathEqual(actual: string, expected: string): void
+	rejects<R = any>(promise: Promise<any>): Promise<R>
+	repeat<R>(
+		fn: () => R | (() => Promise<R>),
+		times: number
+	): ReturnType<typeof fn> extends Promise<R> ? Promise<R> : R
+	resolves(promise: Promise<any>): Promise<void>
+	satisfies<Actual, Expected extends Actual>(actual: Actual, expected: SatisfyExpectation<Expected>): void
+	throws<E extends Error>(value: PromiseLike<any>, error?: ErrorValidator | ErrorConstructor<E>): Promise<E>
+	throws<E extends Error>(value: (...args: any[]) => never, error?: ErrorValidator | ErrorConstructor<E>): E
+	throws<E extends Error, R = any>(
+		value: (...args: any[]) => R,
+		error?: ErrorValidator | ErrorConstructor<E>
+	): R extends Promise<any> ? Promise<E> : E
+	throws<T, R = any>(
+		value: (...args: any[]) => R,
+		validator?: ErrorValidator
+	): R extends Promise<any> ? Promise<T> : T
+	true(value: any): asserts value is true
+	truthy(value: unknown): void
 }
 
 export const assertron: Assertron = {
-  false(value: any) {
-    if (value !== false)
-      throw new AssertionError(notEqualMessage(value, false), { ssf: assertron.false })
-  },
-  falsy,
-  isInstanceof,
-  pathEqual,
-  rejects,
-  repeat,
-  resolves,
-  satisfies,
-  throws,
-  true(value: any) {
-    if (value !== true)
-      throw new AssertionError(notEqualMessage(value, true), { ssf: assertron.true })
-  },
-  truthy
+	false(value: any) {
+		if (value !== false) throw new AssertionError(notEqualMessage(value, false), { ssf: assertron.false })
+	},
+	falsy,
+	isInstanceof,
+	pathEqual,
+	rejects,
+	repeat,
+	resolves,
+	satisfies,
+	throws,
+	true(value: any) {
+		if (value !== true) throw new AssertionError(notEqualMessage(value, true), { ssf: assertron.true })
+	},
+	truthy
 }

package/ts/assertron/falsy.ts

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

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

@@ -1,32 +1,39 @@
 import { createSatisfier } from 'satisfier'
-import { If, IsExtend, NonComposableTypes } from 'type-plus'
+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 { ErrorConstructor, ErrorValidator } from '../types.js'
-import { isErrorConstructor, notRejectedMessage, notThrownMessage, unexpectedErrorMessage } from '../utils/index.js'
+import type { ErrorConstructor, ErrorValidator } from '../types.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 })
 }