assertron 10.0.0 → 10.4.0

package/ts/assert-order/InvalidOrder.ts

@@ -1,35 +1,39 @@
 import { AssertionError } from '../errors.js'
-import { State } from './types.js'
+import type { State } from './types.js'
 
 export class InvalidOrder extends AssertionError {
-  constructor(public state: State, public method: string, public args: any[], options: AssertionError.Options) {
-    super(method === 'end' ? getEndMessage(state) : getExpectingMessage(state, method, args), options)
-  }
+	constructor(
+		public state: State,
+		public method: string,
+		public args: any[],
+		options: AssertionError.Options
+	) {
+		super(method === 'end' ? getEndMessage(state) : getExpectingMessage(state, method, args), options)
+	}
 }
 
 function getEndMessage(state: State) {
-  return `Planned for ${state.maxStep} step but expecting step ${state.step} when 'end()' is called`
+	return `Planned for ${state.maxStep} step but expecting step ${state.step} when 'end()' is called`
 }
 
 function getExpectingMessage(state: State, method: string, args: any[]) {
-  return `Expecting ${getExpectingCalls(state)}, but received '${method}(${getMethodArgs(args)})'`
+	return `Expecting ${getExpectingCalls(state)}, but received '${method}(${getMethodArgs(args)})'`
 }
 
 function getExpectingCalls(state: State) {
-  let message: string
-  if (state.subStep === 0) {
-    const methods = ['is', 'once', 'any']
-    message = methods.map(
-      m => `'${m}(${['any'].indexOf(m) === -1 ? state.step : `[${state.step}]`})'`
-    ).join(', ')
-  }
-  else {
-    const methods = ['exactly']
-    message = methods.map(m => `'${m}(${state.step}, ${state.maxSubStep})'`).join(', ')
-  }
-  return message
+	let message: string
+	if (state.subStep === 0) {
+		const methods = ['is', 'once', 'any']
+		message = methods
+			.map(m => `'${m}(${['any'].indexOf(m) === -1 ? state.step : `[${state.step}]`})'`)
+			.join(', ')
+	} else {
+		const methods = ['exactly']
+		message = methods.map(m => `'${m}(${state.step}, ${state.maxSubStep})'`).join(', ')
+	}
+	return message
 }
 
 function getMethodArgs(args: any[]) {
-  return args.map(a => Array.isArray(a) ? `[${a.join(', ')}]` : a).join(', ')
+	return args.map(a => (Array.isArray(a) ? `[${a.join(', ')}]` : a)).join(', ')
 }

package/ts/assert-order/StateMachine.ts

@@ -1,95 +1,103 @@
-import { performance } from 'perf_hooks'
-import { State } from './types.js'
+import * as perf from 'perf_hooks'
+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 (performance && typeof performance.now === 'function') {
-  let tick: number
-  timeTracker = {
-    start() { tick = performance.now() },
-    taken() { return performance.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

@@ -1,29 +1,67 @@
+import type { AnyConstructor } from 'type-plus'
 import { AssertionError } from '../errors.js'
+import type { ErrorConstructor, ErrorValidator } from '../types.js'
 import { notEqualMessage } from '../utils/index.js'
 import { falsy } from './falsy.js'
+import { isInstanceof } from './isInstanceof.js'
 import { pathEqual } from './pathEqual.js'
 import { rejects } from './rejects.js'
 import { repeat } from './repeat.js'
 import { resolves } from './resolves.js'
-import { satisfies } from './satisfies.js'
+import { satisfies, type SatisfyExpectation } from './satisfies.js'
 import { throws } from './throws.js'
 import { truthy } from './truthy.js'
 
-export const assertron = {
-  false(value: any) {
-    if (value !== false)
-      throw new AssertionError(notEqualMessage(value, false), { ssf: assertron.false })
-  },
-  falsy,
-  pathEqual,
-  rejects,
-  repeat,
-  resolves,
-  satisfies,
-  throws,
-  true(value: any) {
-    if (value !== true)
-      throw new AssertionError(notEqualMessage(value, true), { ssf: assertron.true })
-  },
-  truthy
+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: unknown): asserts value is true
+	truthy(value: unknown): void
+	uuid(value: unknown): void
+}
+
+export const assertron: Assertron = {
+	false(value: unknown): void {
+		if (value !== false) throw new AssertionError(notEqualMessage(value, false), { ssf: assertron.false })
+	},
+	falsy,
+	isInstanceof,
+	pathEqual,
+	rejects,
+	repeat,
+	resolves,
+	satisfies,
+	throws,
+	true(value: unknown): void {
+		if (value !== true) throw new AssertionError(notEqualMessage(value, true), { ssf: assertron.true })
+	},
+	truthy,
+	uuid(value: unknown) {
+		if (typeof value !== 'string')
+			throw new AssertionError(`Expected ${value} to be a string`, { ssf: assertron.uuid })
+
+		if (/^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/.test(value))
+			return
+
+		throw new AssertionError(`Expected ${value} to be a valid UUID`, { ssf: assertron.uuid })
+	}
 }

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 })
+export function falsy(value: unknown): void {
+	if (value) throw new AssertionError(`Expected value to be falsy, but received ${value}`, { ssf: falsy })
 }

package/ts/assertron/index.ts

@@ -1 +1,2 @@
 export * from './assertron.js'
+export type { SatisfyExpectation } from './satisfies.js'

package/ts/assertron/isInstanceof.ts

@@ -0,0 +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
+
+	throw new AssertionError(`Expected ${value} to be an instance of ${type.name}`, { ssf: isInstanceof })
+}

package/ts/assertron/pathEqual.ts

@@ -2,7 +2,7 @@ import { pathEqual as isPathEqual } from 'path-equal'
 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 })
+export function pathEqual(actual: string, expected: string): void {
+	if (!isPathEqual(actual, expected))
+		throw new AssertionError(notEqualMessage(actual, expected), { ssf: pathEqual })
 }

package/ts/assertron/rejects.ts

@@ -1,9 +1,11 @@
 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
-  )
+export function rejects<R = any>(promise: Promise<unknown>): Promise<R> {
+	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

@@ -1,9 +1,11 @@
 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 }) }
-  )
+export function resolves(promise: Promise<any>): Promise<void> {
+	return promise.then(
+		v => v,
+		error => {
+			throw new AssertionError(notResolvedMessage(error), { ssf: resolves })
+		}
+	)
 }

package/ts/assertron/satisfies.ts

@@ -1,31 +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.
+ * @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>
+): void {
+	const diff = createSatisfier(expected as any).exec(actual)
+	if (diff) {
+		throw new AssertionError(notSatisfiedMessage(diff), { ssf: satisfies })
+	}
 }