assertron 7.1.1 → 9.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assertron",
-  "version": "7.1.1",
+  "version": "9.0.0",
   "description": "A supplementary assertion library",
   "homepage": "https://github.com/unional/assertron",
   "bugs": {
@@ -15,41 +15,79 @@
     "name": "Homa Wong",
     "email": "homawong@gmail.com"
   },
+  "sideEffects": false,
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "jsnext:main": "esm/index.js",
+  "browser": {
+    "perf_hooks": false
+  },
+  "typings": "cjs/index.d.ts",
   "files": [
-    "dist",
-    "dist-es5",
-    "dist-es2015",
+    "cjs",
+    "esm",
     "src"
   ],
-  "main": "dist-es5/index.js",
-  "module": "dist-es2015/index.js",
-  "typings": "dist-es5/index.d.ts",
   "scripts": {
-    "build": "npm run build-es5 && npm run build-es2015",
-    "build-es2015": "tsc -p tsconfig.es2015.json",
-    "build-es5": "tsc -p tsconfig.es5.json",
-    "clean": "rimraf dist dist-es5 dist-es2015",
+    "build": "yarn build:esm && yarn build:cjs",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:watch": "tsc --watch",
+    "clean": "rimraf .nyc_output .ts coverage cjs esm",
     "coverage": "jest --coverage",
-    "dependency-check": "dependency-check . --unused --no-dev && dependency-check . --missing --no-dev -i perf_hooks",
-    "lint": "tslint -p tsconfig.json",
+    "depcheck": "yarn dependency-check",
+    "dependency-check": "dependency-check . --unused --no-dev -i type-plus -i global-store -i @types/node -i standard-log-color && dependency-check . --missing --no-dev",
+    "lint": "eslint --ext=js,ts .",
+    "nuke": "yarn clean && rimraf node_modules",
     "test": "jest",
-    "verify": "npm run lint && npm run build && npm run dependency-check && npm run coverage",
-    "watch": "jest --watch"
+    "test:watch": "jest --watch",
+    "verify": "yarn lint && yarn build && yarn dependency-check && yarn coverage",
+    "watch": "yarn test:watch"
   },
-  "browser": {
-    "perf_hooks": false
+  "husky": {
+    "hooks": {
+      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
+    }
   },
   "dependencies": {
-    "assertion-error": "^1.1.0",
     "is-node": "^1.0.2",
-    "is-promise": "^2.1.0",
+    "is-promise": "^4.0.0",
+    "iso-error": "^4.1.0",
     "path-equal": "^1.1.1",
-    "satisfier": "^5.0.2",
-    "tersify": "^3.0.1"
+    "satisfier": "^5.1.1",
+    "tersify": "^3.7.9",
+    "tslib": "^2.3.1",
+    "type-plus": "^3.14.0"
   },
   "devDependencies": {
-    "@types/lodash": "^4.14.126",
-    "@unional/devpkg-node": "^1.3.0",
-    "lodash": "^4.17.11"
+    "@babel/core": "^7.16.5",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.16.5",
+    "@babel/plugin-proposal-optional-chaining": "^7.16.5",
+    "@babel/preset-env": "^7.16.5",
+    "@babel/preset-typescript": "^7.16.5",
+    "@commitlint/cli": "^15.0.0",
+    "@commitlint/config-conventional": "^15.0.0",
+    "@types/jest": "^27.0.3",
+    "@types/lodash": "^4.14.178",
+    "@types/node": "^17.0.4",
+    "@typescript-eslint/eslint-plugin": "^5.8.0",
+    "@typescript-eslint/parser": "^5.8.0",
+    "babel-jest": "^27.4.5",
+    "dependency-check": "^4.1.0",
+    "eslint": "^8.5.0",
+    "eslint-plugin-harmony": "^6.0.0",
+    "husky": "^7.0.4",
+    "jest": "^27.4.5",
+    "jest-junit": "^13.0.0",
+    "jest-progress-tracker": "^3.0.1",
+    "jest-validate": "^27.4.2",
+    "jest-watch-repeat": "^2.0.0",
+    "jest-watch-suspend": "^1.1.2",
+    "jest-watch-toggle-config": "^2.0.1",
+    "jest-watch-typeahead": "^1.0.0",
+    "node-supported-releases": "^0.0.0",
+    "rimraf": "^3.0.2",
+    "typescript": "^4.5.4",
+    "update-notifier": "^5.1.0"
   }
 }

package/src/assert-order/AssertOrder.spec.ts

@@ -1,7 +1,5 @@
-
 import t from 'assert';
-import AssertionError from 'assertion-error';
-import a, { AssertOrder, State } from '..';
+import a, { AssertOrder, InvalidOrder, State } from '..';
 
 test('is() expecting 1', () => {
   const order = new AssertOrder()
@@ -256,7 +254,7 @@ test(`onAny() throws if all assert functions throws`, () => {
 test('AssertOrder(0) accepts no step >= 1', () => {
   const order = new AssertOrder(0)
 
-  const err = a.throws(() => order.once(1)) as AssertionError<{ state: any }>
+  const err = a.throws(() => order.once(1), InvalidOrder)
 
   t.strictEqual(err.state.maxStep, 0)
 })
@@ -266,7 +264,7 @@ test('AssertOrder(1) accepts step 1 but not 2', () => {
 
   order.once(1)
 
-  const err = a.throws(() => order.once(2)) as AssertionError<{ state: any }>
+  const err = a.throws(() => order.once(2), InvalidOrder)
 
   t.strictEqual(err.state.maxStep, 1)
 })
@@ -287,7 +285,7 @@ test('end() would mark to not accepting more steps if plan is not defined', () =
   let order = new AssertOrder()
   order.end()
 
-  let err = a.throws(() => order.once(1)) as AssertionError<{ state: any }>
+  let err = a.throws(() => order.once(1), InvalidOrder)
 
   t.strictEqual(err.state.maxStep, 0)
 
@@ -295,7 +293,7 @@ test('end() would mark to not accepting more steps if plan is not defined', () =
   order.once(1)
   order.end()
 
-  err = a.throws(() => order.once(2)) as AssertionError<{ state: any }>
+  err = a.throws(() => order.once(2), InvalidOrder)
 
   t.strictEqual(err.state.maxStep, 1)
 })
@@ -311,7 +309,7 @@ test('end() throws if planned step not met', () => {
   const order = new AssertOrder(2)
   order.once(1)
 
-  const err = a.throws(() => order.end()) as AssertionError<{ state: any }>
+  const err = a.throws(() => order.end(), InvalidOrder)
 
   t.strictEqual(err.state.maxStep, 2)
 })
@@ -332,7 +330,7 @@ test('end(n) waits n milliseconds and fail when step not met', async () => {
   setTimeout(() => {
     order.once(1)
   }, 10)
-  const err = await a.throws(order.end(1)) as AssertionError<{ state: any }>
+  const err = await a.throws(order.end(1), InvalidOrder)
 
   t.strictEqual(err.state.maxStep, 1)
 })
@@ -422,7 +420,7 @@ test('wait(step, callback) will execute the async callback but not wait for it a
   const o2 = new AssertOrder(1)
 
   order.wait(1, () => {
-    return new Promise(a => {
+    return new Promise<void>(a => {
       setImmediate(() => {
         o2.once(1)
         a()
@@ -435,8 +433,8 @@ test('wait(step, callback) will execute the async callback but not wait for it a
   return o2.end(100)
 })
 
-async function assertOrderThrows(fn, state: Partial<State>, method, ...args) {
-  const err = await a.throws(fn) as AssertionError<{ state: any, method: string, args: any[] }>
+async function assertOrderThrows(fn: () => any, state: Partial<State>, method: string, ...args: any[]) {
+  const err = await a.throws(fn, InvalidOrder)
   t.strictEqual(err.method, method)
   t.deepStrictEqual(err.args, args)
   if (state.step) {

package/src/assert-order/AssertOrder.ts

@@ -31,7 +31,7 @@ export class AssertOrder {
    */
   not(step: number) {
     if (this.state.isValid(step)) {
-      throw new InvalidOrder(this.state.get(), 'not', this.not, step)
+      throw new InvalidOrder(this.state.get(), 'not', [step], { ssf: this.not })
     }
   }
 
@@ -73,21 +73,21 @@ export class AssertOrder {
       return this.state.moveSubStep()
     }
     else
-      throw new InvalidOrder(this.state.get(), 'atLeastOnce', this.atLeastOnce, step)
+      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', this.any, steps)
+      throw new InvalidOrder(this.state.get(), 'any', [steps], { ssf: this.any })
 
     this.state.move()
     return steps[index]
   }
-  onAny(steps: number[], ...asserts: Function[]) {
+  onAny(steps: number[], ...asserts: Array<(...args: any[]) => any>) {
     steps.forEach(step => {
       this.state.on(step, () => {
-        let firstError
+        let firstError: any
         let hasPass = false
         asserts.forEach(assert => {
           try {
@@ -121,12 +121,12 @@ export class AssertOrder {
     }
 
     if (this.state.isAccepting()) {
-      throw new InvalidOrder(this.state.get(), 'end', this.end)
+      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', this.exactly, step, times)
+      throw new InvalidOrder(this.state.get(), 'exactly', [step, times], { ssf: this.exactly })
 
     if (this.state.maxSubStep === undefined) {
       this.state.maxSubStep = times
@@ -145,7 +145,7 @@ export class AssertOrder {
   }
   private assert(method: string, step: number) {
     if (this.state.isNotValid(step)) {
-      throw new InvalidOrder(this.state.get(), method, this[method], step)
+      throw new InvalidOrder(this.state.get(), method, [step], { ssf: (this as any)[method] })
     }
   }
 }

package/src/assert-order/InvalidOrder.ts

@@ -1,13 +1,9 @@
-import AssertionError from 'assertion-error';
-import { State } from './interfaces';
+import { AssertionError } from '../errors'
+import { State } from './types'
 
 export class InvalidOrder extends AssertionError {
-  method: string
-  args: any[]
-  state: State
-  constructor(state: State, method: string, ssf: Function, ...args: any[]) {
-    const message = method === 'end' ? getEndMessage(state) : getExpectingMessage(state, method, args)
-    super(message, { method, state, args }, ssf)
+  constructor(public state: State, public method: string, public args: any[], options: AssertionError.Options) {
+    super(method === 'end' ? getEndMessage(state) : getExpectingMessage(state, method, args), options)
   }
 }
 
@@ -15,7 +11,7 @@ function getEndMessage(state: State) {
   return `Planned for ${state.maxStep} step but expecting step ${state.step} when 'end()' is called`
 }
 
-function getExpectingMessage(state, method, args) {
+function getExpectingMessage(state: State, method: string, args: any[]) {
   return `Expecting ${getExpectingCalls(state)}, but received '${method}(${getMethodArgs(args)})'`
 }
 
@@ -23,9 +19,8 @@ function getExpectingCalls(state: State) {
   let message: string
   if (state.subStep === 0) {
     const methods = ['is', 'once', 'any']
-    message = methods.map(m => ['any'].indexOf(m) === -1 ?
-      `'${m}(${state.step})'` :
-      `'${m}([${state.step}])'`
+    message = methods.map(
+      m => `'${m}(${['any'].indexOf(m) === -1 ? state.step : `[${state.step}]`})'`
     ).join(', ')
   }
   else {

package/src/assert-order/StateMachine.ts

@@ -1,11 +1,10 @@
 import isNode from 'is-node'
-import { State } from './interfaces'
+import { State } from './types'
 
 // istanbul ignore next
 function nodeVersionIsOrAbove(major: number, minor = 0, patch = 0) {
-  // without this, systemjs will complain `process is not defined`
-  if (!global.process)
-    return false
+  // without this, systemJS will complain `process is not defined`
+  if (!global.process) return false
   const versionString = process.version.startsWith('v') ? process.version.slice(1) : process.version
   const [actualMajor, actualMinor, actualPatch] = versionString.split('.').map(s => parseInt(s, 10))
   const checking = major * 1000 * 1000 + minor * 1000 + patch
@@ -14,48 +13,47 @@ function nodeVersionIsOrAbove(major: number, minor = 0, patch = 0) {
 }
 
 // istanbul ignore next
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 const performance = isNode && nodeVersionIsOrAbove(8, 5) ? require('perf_hooks').performance : undefined
 
-let startTick
-let timeTaken
+let timeTracker: { start(): void, taken(): number }
 // istanbul ignore else
-// tslint:disable-next-line
 if (process && typeof process.hrtime === 'function') {
-  startTick = process.hrtime
-  timeTaken = function (startTick) {
-    const [second, nanoSecond] = process.hrtime(startTick)
-    return second * 1000 + nanoSecond / 1e6
+  let tick: [number, number]
+  timeTracker = {
+    start() { tick = process.hrtime() },
+    taken() {
+      const [second, nanoSecond] = process.hrtime(tick)
+      return second * 1000 + nanoSecond / 1e6
+    }
   }
 }
-// tslint:disable-next-line
 else if (performance && typeof performance.now === 'function') {
-  startTick = performance.now
-  timeTaken = function (startTick) {
-    const end = performance.now()
-    return end - startTick
+  let tick: number
+  timeTracker = {
+    start() { tick = performance.now() },
+    taken() { return performance.now() - tick }
   }
 }
 else {
-  startTick = function () {
-    return new Date().valueOf()
-  }
-  timeTaken = function (startTick) {
-    return new Date().valueOf() - startTick
+  let tick: number
+  timeTracker = {
+    start() { tick = new Date().valueOf() },
+    taken() { return new Date().valueOf() - tick }
   }
 }
 
 export class StateMachine {
-  listeners = {}
-  step: number = 1
+  listeners: Record<number, Array<() => void>> = {}
+  step = 1
   maxStep?: number
 
-  subStep: number = 0
+  subStep = 0
   minSubStep?: number
   maxSubStep?: number
-  private startTick: [number, number] | number
   constructor(maxStep?: number) {
     this.maxStep = maxStep
-    this.startTick = this.getStartTick()
+    timeTracker.start()
   }
   jump(step: number) {
     this.step = step
@@ -87,7 +85,7 @@ export class StateMachine {
       maxSubStep
     }
   }
-  on(step: number, listener) {
+  on(step: number, listener: () => void) {
     this.listeners[step] = [listener]
   }
   isNotValid(step: number) {
@@ -107,9 +105,6 @@ export class StateMachine {
     return this.maxStep ? this.maxStep >= this.step : true
   }
   getTimeTaken() {
-    return timeTaken(this.startTick)
-  }
-  private getStartTick() {
-    return startTick()
+    return timeTracker.taken()
   }
 }

package/src/assert-order/index.ts

@@ -1,2 +1,4 @@
 export * from './AssertOrder'
-export * from './interfaces'
+export * from './InvalidOrder'
+export * from './types'
+

package/src/assert-order/internalInterfaces.ts

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

package/src/assert-order/types.ts

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

package/src/assertron/assertron.spec.ts

@@ -1,6 +1,5 @@
-import AssertionError from 'assertion-error';
-import a from '..';
-import { assertThrows, noStackTraceFor } from '../testUtils';
+import a, { AssertionError } from '..'
+import { assertThrows, noStackTraceFor } from '../testUtils'
 
 describe('false()', () => {
   test('non-false statement throws', () => {
@@ -21,7 +20,6 @@ describe('false()', () => {
   })
 })
 
-
 describe('true()', () => {
   test('non-true statement throws', () => {
     assertThrows(() => a.true(false), AssertionError)

package/src/assertron/assertron.ts

@@ -1,20 +1,18 @@
-import AssertionError from 'assertion-error';
-import { falsy } from './falsy';
-import { pathEqual } from './pathEqual';
-import { rejects } from './rejects';
-import { repeat } from './repeat';
-import { resolves } from './resolves';
-import { satisfies } from './satisfies';
-import { throws } from './throws';
-import { truthy } from './truthy';
+import { AssertionError } from '../errors'
+import { notEqualMessage } from '../utils'
+import { falsy } from './falsy'
+import { pathEqual } from './pathEqual'
+import { rejects } from './rejects'
+import { repeat } from './repeat'
+import { resolves } from './resolves'
+import { satisfies } from './satisfies'
+import { throws } from './throws'
+import { truthy } from './truthy'
 
 export const assertron = {
   false(value: any) {
     if (value !== false)
-      throw new AssertionError(
-        `Expected value to equal false, but received ${value}`,
-        { value },
-        assertron.false)
+      throw new AssertionError(notEqualMessage(value, false), { ssf: assertron.false })
   },
   falsy,
   pathEqual,
@@ -24,7 +22,8 @@ export const assertron = {
   satisfies,
   throws,
   true(value: any) {
-    if (value !== true) throw new AssertionError(`Expected value to equal true, but received ${value}`, { value }, assertron.true)
+    if (value !== true)
+      throw new AssertionError(notEqualMessage(value, true), { ssf: assertron.true })
   },
   truthy
 }

package/src/assertron/falsy.spec.ts

@@ -1,6 +1,5 @@
-import a from '..';
-import AssertionError from 'assertion-error'
-import { assertThrows, noStackTraceFor } from '../testUtils';
+import a, { AssertionError } from '..'
+import { assertThrows, noStackTraceFor } from '../testUtils'
 
 test('non-false statement throws', () => {
   assertThrows(() => a.falsy(true), AssertionError)

package/src/assertron/falsy.ts

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

package/src/assertron/pathEqual.spec.ts

@@ -1,6 +1,5 @@
-import AssertionError from 'assertion-error';
-import assertron from '..';
-import { assertThrows, noStackTraceFor } from '../testUtils';
+import assertron, { AssertionError } from '..'
+import { assertThrows, noStackTraceFor } from '../testUtils'
 
 test('path with same style passes', () => {
   assertron.pathEqual('a', 'a')

package/src/assertron/pathEqual.ts

@@ -1,11 +1,8 @@
-import AssertionError from 'assertion-error';
-import { pathEqual as isPathEqual } from 'path-equal';
-import { notEqualMessage } from '../errors';
+import { pathEqual as isPathEqual } from 'path-equal'
+import { AssertionError } from '../errors'
+import { notEqualMessage } from '../utils'
 
 export function pathEqual(actual: string, expected: string) {
   if (!isPathEqual(actual, expected))
-    throw new AssertionError(
-      notEqualMessage(actual, expected),
-      { actual, expected },
-      pathEqual)
+    throw new AssertionError(notEqualMessage(actual, expected), { ssf: pathEqual })
 }

package/src/assertron/rejects.spec.ts

@@ -1,7 +1,6 @@
-import t from 'assert';
-import AssertionError from 'assertion-error';
-import a from '..';
-import { assertAsyncThrows, noStackTraceFor } from '../testUtils';
+import t from 'assert'
+import a from '..'
+import { assertAsyncThrows, noStackTraceFor } from '../testUtils'
 
 test('pass on rejected promise', async () => {
   await a.rejects(Promise.reject(1))
@@ -12,22 +11,22 @@ test('throws on resolved string promise', async () => {
   t.strictEqual(err.message, `Expected promise to reject, but it resolves with 'abc'`)
 })
 
-test('throws on resovled boolean promise', async () => {
+test('throws on resolved boolean promise', async () => {
   const err = await a.throws(a.rejects(Promise.resolve(true)))
   t.strictEqual(err.message, `Expected promise to reject, but it resolves with true`)
 })
 
-test('throws on resovled object promise', async () => {
+test('throws on resolved object promise', async () => {
   const err = await a.throws(a.rejects(Promise.resolve(2)))
   t.strictEqual(err.message, `Expected promise to reject, but it resolves with 2`)
 })
 
-test('throws on resovled object promise', async () => {
+test('throws on resolved object promise', async () => {
   const err = await a.throws(a.rejects(Promise.resolve({ a: 1 })))
   t.strictEqual(err.message, `Expected promise to reject, but it resolves with { a: 1 }`)
 })
 
 test('does not contain internal stack trace', async () => {
-  const err = await assertAsyncThrows(() => a.rejects(Promise.resolve({ a: 1 })), AssertionError)
+  const err = await assertAsyncThrows(() => a.rejects(Promise.resolve({ a: 1 })))
   noStackTraceFor('rejects.ts', err)
 })

package/src/assertron/rejects.ts

@@ -1,17 +1,9 @@
-import { tersify } from 'tersify';
-import AssertionError from 'assertion-error';
+import { AssertionError } from '../errors'
+import { notRejectedMessage } from '../utils'
 
 export function rejects(promise: Promise<any>) {
   return promise.then(
-    value => {
-      throw new AssertionError(
-        `Expected promise to reject, but it resolves with ${
-        typeof value === 'string' ?
-          `'${value}'` :
-          tersify(value, { maxLength: Infinity })}`,
-        { value },
-        rejects)
-    },
+    value => { throw new AssertionError(notRejectedMessage(value), { ssf: rejects }) },
     () => { }
   )
 }

package/src/assertron/repeat.spec.ts

@@ -1,5 +1,4 @@
-import a from '..'
-import { FailOnOccurance } from './repeat';
+import a, { FailOnOccurrence } from '..'
 
 test('repeat function n times', () => {
   let count = 0
@@ -11,7 +10,7 @@ test('repeat function n times', () => {
 test('repeat async function n times sequentially', async () => {
   let count = 0
   let actual = ''
-  let aa = await a.repeat(() => new Promise<string>(a => {
+  const aa = await a.repeat(() => new Promise<string>(a => {
     setTimeout(() => {
       ++count
       actual += String(count)
@@ -26,24 +25,23 @@ test('repeat async function n times sequentially', async () => {
 test('error is captured as inner error and indicate which call failed', () => {
   let count = 0
   const err = a.throws(() => a.repeat(() => {
-    ++count
-    if (count === 5) throw new Error('failed')
-  }, 10), FailOnOccurance)
+    if (++count === 5) throw new Error('failed')
+  }, 10), FailOnOccurrence)
 
-  expect(err.occurance).toBe(5)
+  expect(err.occurrence).toBe(5)
   expect(err.error.message).toBe('failed')
 })
 
 test('rejected error is captured as inner error and indicate which call failed', async () => {
   let count = 0
-  let err = await a.throws(a.repeat(() => new Promise((a, r) => {
+  const err = await a.throws(a.repeat(() => new Promise<void>((a, r) => {
     setTimeout(() => {
       ++count
       if (count === 5) r(new Error('failed'))
       else a()
     }, Math.random() * 10)
-  }), 10), FailOnOccurance)
+  }), 10), FailOnOccurrence)
 
-  expect(err.occurance).toBe(5)
+  expect(err.occurrence).toBe(5)
   expect(err.error.message).toBe('failed')
 })