assertron 11.2.0 → 11.2.2

package/ts/assert-order/AssertOrder.ts

@@ -5,147 +5,142 @@ import { StateMachine } from './StateMachine.js'
 // order.atMost(step, count) // exected to be executed at most `count` times
 
 export class AssertOrder {
-  /**
-   * Gets the current expecting step.
-   */
-  get currentStep() {
-    return this.state.step
-  }
-
-  private state: StateMachine
-  constructor(plan?: number) {
-    this.state = new StateMachine(plan)
-  }
-
-  /**
-   * Asserts the current step is `step`.
-   * @param step expected step.
-   */
-  is(step: number) {
-    this.assert('is', step)
-  }
-
-  /**
-   * Asserts the current step is not `step`.
-   * @param step not expected step.
-   */
-  not(step: number) {
-    if (this.state.isValid(step)) {
-      throw new InvalidOrder(this.state.get(), 'not', [step], { ssf: this.not })
-    }
-  }
-
-  /**
-   * Reset to specified step.
-   */
-  jump(step: number) {
-    this.state.jump(step)
-  }
-
-  /**
-   * Move to next step.
-   */
-  move() {
-    this.state.move()
-  }
-
-  /**
-   * Asserts the specified step will run once.
-   */
-  once(step: number) {
-    this.assert('once', step)
-    this.state.move()
-  }
-
-  on(step: number, assert: (step: number) => void) {
-    this.state.on(step, () => {
-      assert(step)
-    })
-  }
-
-  atLeastOnce(step: number) {
-    const nextStep = step + 1
-    if (this.state.step === step) {
-      this.state.move()
-      return this.state.moveSubStep()
-    }
-    else if (this.state.step === nextStep && this.state.subStep > 0) {
-      return this.state.moveSubStep()
-    }
-    else
-      throw new InvalidOrder(this.state.get(), 'atLeastOnce', [step], { ssf: this.atLeastOnce })
-  }
-
-  any(steps: number[]) {
-    const index = steps.indexOf(this.state.step)
-    if (index === -1)
-      throw new InvalidOrder(this.state.get(), 'any', [steps], { ssf: this.any })
-
-    this.state.move()
-    return steps[index]
-  }
-  onAny(steps: number[], ...asserts: Array<(...args: any[]) => any>) {
-    steps.forEach(step => {
-      this.state.on(step, () => {
-        let firstError: any
-        let hasPass = false
-        asserts.forEach(assert => {
-          try {
-            assert(step)
-            hasPass = true
-          }
-          catch (err) {
-            if (!firstError) firstError = err
-          }
-        })
-        if (!hasPass)
-          throw firstError
-      })
-    })
-    return
-  }
-  end(timeout: number): Promise<number>
-  end(): number
-  end(timeout?: number) {
-    if (timeout) {
-      return new Promise(r => {
-        setTimeout(r, timeout)
-      }).then(() => {
-        return this.end()
-      })
-    }
-
-    if (!this.state.isMaxStepDefined()) {
-      this.state.stopAccepting()
-      return this.state.getTimeTaken()
-    }
-
-    if (this.state.isAccepting()) {
-      throw new InvalidOrder(this.state.get(), 'end', [], { ssf: this.end })
-    }
-  }
-  exactly(step: number, times: number) {
-    if (this.state.isNotValid(step))
-      throw new InvalidOrder(this.state.get(), 'exactly', [step, times], { ssf: this.exactly })
-
-    if (this.state.maxSubStep === undefined) {
-      this.state.maxSubStep = times
-      this.state.minSubStep = times
-    }
-
-    return this.state.moveSubStep()
-  }
-  wait(step: number): Promise<void>
-  wait(step: number, callback: () => void): void
-  wait(step: number, callback?: () => void) {
-    if (callback)
-      this.on(step, callback)
-    else
-      return new Promise<any>(a => { this.on(step, a) })
-  }
-  private assert(method: string, step: number) {
-    if (this.state.isNotValid(step)) {
-      throw new InvalidOrder(this.state.get(), method, [step], { ssf: (this as any)[method] })
-    }
-  }
+	/**
+	 * Gets the current expecting step.
+	 */
+	get currentStep() {
+		return this.state.step
+	}
+
+	private state: StateMachine
+	constructor(plan?: number) {
+		this.state = new StateMachine(plan)
+	}
+
+	/**
+	 * Asserts the current step is `step`.
+	 * @param step expected step.
+	 */
+	is(step: number) {
+		this.assert('is', step)
+	}
+
+	/**
+	 * Asserts the current step is not `step`.
+	 * @param step not expected step.
+	 */
+	not(step: number) {
+		if (this.state.isValid(step)) {
+			throw new InvalidOrder(this.state.get(), 'not', [step], { ssf: this.not })
+		}
+	}
+
+	/**
+	 * Reset to specified step.
+	 */
+	jump(step: number) {
+		this.state.jump(step)
+	}
+
+	/**
+	 * Move to next step.
+	 */
+	move() {
+		this.state.move()
+	}
+
+	/**
+	 * Asserts the specified step will run once.
+	 */
+	once(step: number) {
+		this.assert('once', step)
+		this.state.move()
+	}
+
+	on(step: number, assert: (step: number) => void) {
+		this.state.on(step, () => {
+			assert(step)
+		})
+	}
+
+	atLeastOnce(step: number) {
+		const nextStep = step + 1
+		if (this.state.step === step) {
+			this.state.move()
+			return this.state.moveSubStep()
+		} else if (this.state.step === nextStep && this.state.subStep > 0) {
+			return this.state.moveSubStep()
+		} else throw new InvalidOrder(this.state.get(), 'atLeastOnce', [step], { ssf: this.atLeastOnce })
+	}
+
+	any(steps: number[]) {
+		const index = steps.indexOf(this.state.step)
+		if (index === -1) throw new InvalidOrder(this.state.get(), 'any', [steps], { ssf: this.any })
+
+		this.state.move()
+		return steps[index]
+	}
+	onAny(steps: number[], ...asserts: Array<(...args: any[]) => any>) {
+		steps.forEach(step => {
+			this.state.on(step, () => {
+				let firstError: any
+				let hasPass = false
+				asserts.forEach(assert => {
+					try {
+						assert(step)
+						hasPass = true
+					} catch (err) {
+						if (!firstError) firstError = err
+					}
+				})
+				if (!hasPass) throw firstError
+			})
+		})
+		return
+	}
+	end(timeout: number): Promise<number>
+	end(): number
+	end(timeout?: number) {
+		if (timeout) {
+			return new Promise(r => {
+				setTimeout(r, timeout)
+			}).then(() => {
+				return this.end()
+			})
+		}
+
+		if (!this.state.isMaxStepDefined()) {
+			this.state.stopAccepting()
+			return this.state.getTimeTaken()
+		}
+
+		if (this.state.isAccepting()) {
+			throw new InvalidOrder(this.state.get(), 'end', [], { ssf: this.end })
+		}
+	}
+	exactly(step: number, times: number) {
+		if (this.state.isNotValid(step))
+			throw new InvalidOrder(this.state.get(), 'exactly', [step, times], { ssf: this.exactly })
+
+		if (this.state.maxSubStep === undefined) {
+			this.state.maxSubStep = times
+			this.state.minSubStep = times
+		}
+
+		return this.state.moveSubStep()
+	}
+	wait(step: number): Promise<void>
+	wait(step: number, callback: () => void): void
+	wait(step: number, callback?: () => void) {
+		if (callback) this.on(step, callback)
+		else
+			return new Promise<any>(a => {
+				this.on(step, a)
+			})
+	}
+	private assert(method: string, step: number) {
+		if (this.state.isNotValid(step)) {
+			throw new InvalidOrder(this.state.get(), method, [step], { ssf: (this as any)[method] })
+		}
+	}
 }

package/ts/assert-order/InvalidOrder.ts

@@ -2,34 +2,38 @@ import { AssertionError } from '../errors.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,96 +1,103 @@
 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 (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

@@ -13,38 +13,45 @@ 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 })
 }