assertron 7.1.0 → 8.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "assertron",
-  "version": "7.1.0",
-  "description": "A supplementary assertion library",
+  "version": "8.0.0",
+  "description": "A supplementary assertion cjsrary",
   "homepage": "https://github.com/unional/assertron",
   "bugs": {
     "url": "https://github.com/unional/assertron/issues"
@@ -15,41 +15,80 @@
     "name": "Homa Wong",
     "email": "homawong@gmail.com"
   },
+  "sideEffects": false,
+  "type": "module",
+  "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",
     "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.13.1"
   },
   "devDependencies": {
-    "@types/lodash": "^4.14.126",
-    "@unional/devpkg-node": "^1.3.0",
-    "lodash": "^4.17.11"
+    "@babel/core": "^7.12.16",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.12.13",
+    "@babel/plugin-proposal-optional-chaining": "^7.12.16",
+    "@babel/preset-env": "^7.12.16",
+    "@babel/preset-typescript": "^7.12.16",
+    "@commitlint/cli": "^15.0.0",
+    "@commitlint/config-conventional": "^15.0.0",
+    "@types/jest": "^27.0.3",
+    "@types/lodash": "^4.14.149",
+    "@types/node": "^16.11.11",
+    "@typescript-eslint/eslint-plugin": "^5.5.0",
+    "@typescript-eslint/parser": "^5.5.0",
+    "babel-jest": "^27.4.2",
+    "dependency-check": "^4.1.0",
+    "eslint": "^8.4.0",
+    "eslint-plugin-harmony": "^6.0.0",
+    "husky": "^7.0.4",
+    "jest": "^27.4.3",
+    "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.1.5",
+    "update-notifier": "^5.1.0"
   }
 }

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

@@ -1,4 +1,3 @@
-
 import t from 'assert';
 import AssertionError from 'assertion-error';
 import a, { AssertOrder, State } from '..';

package/src/assert-order/AssertOrder.ts

@@ -84,10 +84,10 @@ export class AssertOrder {
     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 {
@@ -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, (this as any)[method], step)
     }
   }
 }

package/src/assert-order/InvalidOrder.ts

@@ -1,11 +1,8 @@
-import AssertionError from 'assertion-error';
-import { State } from './interfaces';
+import AssertionError from 'assertion-error'
+import { State } from './interfaces'
 
-export class InvalidOrder extends AssertionError {
-  method: string
-  args: any[]
-  state: State
-  constructor(state: State, method: string, ssf: Function, ...args: any[]) {
+export class InvalidOrder extends AssertionError<{ method: string, state: State, args: any[] }> {
+  constructor(state: State, method: string, ssf: (...args: any[]) => any, ...args: any[]) {
     const message = method === 'end' ? getEndMessage(state) : getExpectingMessage(state, method, args)
     super(message, { method, state, args }, ssf)
   }
@@ -15,7 +12,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)})'`
 }
 

package/src/assert-order/StateMachine.ts

@@ -3,7 +3,7 @@ import { State } from './interfaces'
 
 // istanbul ignore next
 function nodeVersionIsOrAbove(major: number, minor = 0, patch = 0) {
-  // without this, systemjs will complain `process is not defined`
+  // 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
@@ -14,48 +14,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 +86,7 @@ export class StateMachine {
       maxSubStep
     }
   }
-  on(step: number, listener) {
+  on(step: number, listener: () => void) {
     this.listeners[step] = [listener]
   }
   isNotValid(step: number) {
@@ -107,9 +106,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/interfaces.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/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/assertron/assertron.spec.ts

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

package/src/assertron/assertron.ts

@@ -1,12 +1,12 @@
-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 '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'
 
 export const assertron = {
   false(value: any) {

package/src/assertron/falsy.spec.ts

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

package/src/assertron/pathEqual.spec.ts

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

package/src/assertron/pathEqual.ts

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

package/src/assertron/rejects.spec.ts

@@ -1,7 +1,7 @@
-import t from 'assert';
-import AssertionError from 'assertion-error';
-import a from '..';
-import { assertAsyncThrows, noStackTraceFor } from '../testUtils';
+import t from 'assert'
+import AssertionError from 'assertion-error'
+import a from '..'
+import { assertAsyncThrows, noStackTraceFor } from '../testUtils'
 
 test('pass on rejected promise', async () => {
   await a.rejects(Promise.reject(1))
@@ -12,17 +12,17 @@ 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 }`)
 })

package/src/assertron/rejects.ts

@@ -1,14 +1,12 @@
-import { tersify } from 'tersify';
-import AssertionError from 'assertion-error';
+import { tersify } from 'tersify'
+import AssertionError from 'assertion-error'
 
 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 })}`,
+        `Expected promise to reject, but it resolves with ${typeof value === 'string' ?
+          `'${value}'` : tersify(value, { maxLength: Infinity })}`,
         { value },
         rejects)
     },

package/src/assertron/repeat.spec.ts

@@ -1,4 +1,5 @@
 import a from '..'
+import { FailOnOccurrence } from './repeat'
 
 test('repeat function n times', () => {
   let count = 0
@@ -10,7 +11,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)
@@ -21,3 +22,28 @@ test('repeat async function n times sequentially', async () => {
   expect(actual).toBe('12345678910')
   expect(actual).toBe(aa)
 })
+
+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), FailOnOccurrence)
+
+  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
+  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), FailOnOccurrence)
+
+  expect(err.occurrence).toBe(5)
+  expect(err.error.message).toBe('failed')
+})

package/src/assertron/repeat.ts

@@ -1,20 +1,37 @@
 import isPromise from 'is-promise';
+import AssertionError from 'assertion-error'
 
 /**
  * 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 {
-  const result = fn()
-  if (isPromise(result)) {
-    if (times <= 1) return result as any
-    return result.then(() => repeat(fn, times - 1)) as any
-  }
-  else {
-    let result
-    for (let i = 1; i < times; i++) {
-      result = fn()
+  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
+
+    if (isPromise(result)) {
+      return result.then(
+        () => repeatRecur(fn, i + 1, times),
+        (e) => { throw new FailOnOccurrence(i, e) }
+      ) as any
+    }
+    else {
+      return repeatRecur(fn, i + 1, times)
     }
-    return result
+  }
+  catch (e) {
+    if (e instanceof FailOnOccurrence) throw e
+    throw new FailOnOccurrence(i, e)
+  }
+}
+
+export class FailOnOccurrence extends AssertionError<{ occurrence: number }> {
+  constructor(public occurrence: number, public error: any) {
+    super(`Failed on ${occurrence} occurrence`)
   }
 }

package/src/assertron/resolves.spec.ts

@@ -1,7 +1,7 @@
-import t from 'assert';
-import a from '..';
-import AssertionError from 'assertion-error';
-import { assertAsyncThrows, noStackTraceFor } from '../testUtils';
+import t from 'assert'
+import a from '..'
+import AssertionError from 'assertion-error'
+import { assertAsyncThrows, noStackTraceFor } from '../testUtils'
 
 
 test('pass on resolved promise', async () => {

package/src/assertron/resolves.ts

@@ -1,18 +1,15 @@
-import { tersify } from 'tersify';
-import AssertionError from 'assertion-error';
+import { tersify } from 'tersify'
+import AssertionError from 'assertion-error'
 
 export function resolves(promise: Promise<any>) {
   return promise.then(
     () => { },
     error => {
-      throw new AssertionError(`Expected promise to resolve, but it rejects with ${
-        typeof error === 'string' ?
-          `'${error}'` :
-          error instanceof Error ?
-            error :
-            tersify(error, { maxLength: Infinity })}`,
-        { error },
-        resolves
+      throw new AssertionError(`Expected promise to resolve, but it rejects with ${typeof error === 'string' ?
+        `'${error}'` :
+        error instanceof Error ?
+          error :
+          tersify(error, { maxLength: Infinity })}`, { error }, resolves
       )
     }
   )

package/src/assertron/satisfies.spec.ts

@@ -1,7 +1,7 @@
-import AssertionError from 'assertion-error';
-import { every } from 'satisfier';
-import a from '..';
-import { assertThrows, noStackTraceFor } from '../testUtils';
+import AssertionError from 'assertion-error'
+import { every } from 'satisfier'
+import a from '..'
+import { assertThrows, noStackTraceFor } from '../testUtils'
 
 test('primitive types will pass', () => {
   a.satisfies(1, 1)
@@ -74,12 +74,11 @@ test('function will use as predicate', () => {
 })
 
 test('predicate error should mention path', () => {
-  a.throws(() => a.satisfies({ a: 1 }, { a: () => false }), e => e.message === `Expect a to satisfy fn() { return false }, but received 1`)
+  a.throws(() => a.satisfies({ a: 1 }, { a: () => false }), e => e.message === `Expect a to satisfy () => false, but received 1`)
 })
 
 test('deep predicate error should mention path', () => {
-
-  a.throws(() => a.satisfies({ a: { b: 1 } }, { a: { b: b => b === 2 } }), e => e.message === `Expect a.b to satisfy fn(b) { return b === 2 }, but received 1`)
+  a.throws(() => a.satisfies({ a: { b: 1 } }, { a: { b: b => b === 2 } }), e => e.message === `Expect a.b to satisfy b => b === 2, but received 1`)
 })
 
 test('can check parent property', () => {
@@ -94,7 +93,7 @@ test('can check parent property', () => {
 })
 
 test('actual of type any should not have type checking error', () => {
-  let actual: any = { a: 1 }
+  const actual: any = { a: 1 }
   a.satisfies(actual, { a: 1 })
 })
 
@@ -102,7 +101,7 @@ test('Work with null in array', () => {
   interface Foo {
     payload: any;
   }
-  let action: Foo = { payload: [null, 3, 4] }
+  const action: Foo = { payload: [null, 3, 4] }
   a.satisfies(action, { payload: [null, 3, 4] })
 })
 

package/src/assertron/satisfies.ts

@@ -1,13 +1,23 @@
-import AssertionError from 'assertion-error';
-import { createSatisfier } from 'satisfier';
-import { notSatisfiedMessage } from '../errors';
+import AssertionError from 'assertion-error'
+import { createSatisfier } from 'satisfier'
+import { And, If, PrimitiveTypes, IsExtend } from 'type-plus'
+import { notSatisfiedMessage } from '../errors'
+
+export type SatisfyExpectation<T> = If<
+  And<IsExtend<T, PrimitiveTypes>, IsExtend<T, Array<any>>>,
+  T | ((v: T) => boolean),
+  {
+    [P in keyof T]?: T[P] extends string
+    ? SatisfyExpectation<T[P]> | ((v: T[P]) => boolean) | RegExp
+    : SatisfyExpectation<T[P]> | ((v: T[P]) => 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 extends any>(actual: Actual, expected: any) {
-  const diff = createSatisfier(expected).exec(actual);
+export function satisfies<Actual>(actual: Actual, expected: SatisfyExpectation<Actual>) {
+  const diff = createSatisfier(expected as any).exec(actual);
   if (diff) {
     throw new AssertionError(
       notSatisfiedMessage(diff),