assertron 7.1.3 → 8.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "assertron",
-  "version": "7.1.3",
-  "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"
@@ -16,31 +16,30 @@
     "email": "homawong@gmail.com"
   },
   "sideEffects": false,
-  "main": "lib/index.js",
-  "module": "libm/index.js",
-  "jsnext:main": "libm/index.js",
+  "type": "module",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "jsnext:main": "esm/index.js",
   "browser": {
     "perf_hooks": false
   },
-  "typings": "lib/index.d.ts",
+  "typings": "cjs/index.d.ts",
   "files": [
-    "lib",
-    "libm",
+    "cjs",
+    "esm",
     "src"
   ],
   "scripts": {
-    "build": "yarn build:libm && yarn build:lib",
-    "build:lib": "tsc -p tsconfig.lib.json",
-    "build:libm": "tsc -p tsconfig.libm.json",
+    "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 lib libm",
-    "codacy": "cat coverage/lcov.info | codacy-coverage",
+    "clean": "rimraf .nyc_output .ts coverage cjs esm",
     "coverage": "jest --coverage",
     "depcheck": "yarn dependency-check",
-    "dependency-check": "dependency-check . --unused --no-dev -i global-store -i @types/node -i standard-log-color && dependency-check . --missing --no-dev",
+    "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",
-    "semantic-release": "semantic-release",
     "test": "jest",
     "test:watch": "jest --watch",
     "verify": "yarn lint && yarn build && yarn dependency-check && yarn coverage",
@@ -54,26 +53,42 @@
   "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.1.0",
-    "tersify": "^3.7.0",
-    "tslib": "^1.11.1"
+    "satisfier": "^5.1.1",
+    "tersify": "^3.7.9",
+    "tslib": "^2.3.1",
+    "type-plus": "^3.13.1"
   },
   "devDependencies": {
-    "@babel/core": "^7.8.6",
-    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.8.3",
-    "@babel/plugin-proposal-optional-chaining": "^7.8.3",
-    "@babel/preset-env": "^7.8.6",
-    "@babel/preset-typescript": "^7.8.3",
-    "@commitlint/cli": "^8.3.5",
-    "@commitlint/config-conventional": "^8.3.4",
+    "@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",
-    "@unional/devpkg-node": "^1.5.0",
-    "codacy-coverage": "^3.4.0",
-    "commitlint-circle": "^1.0.0",
-    "husky": "^4.2.3",
-    "lodash": "^4.17.15",
-    "semantic-release": "^17.0.4"
+    "@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.ts

@@ -84,7 +84,7 @@ 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: any

package/src/assert-order/InvalidOrder.ts

@@ -1,8 +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 {
-  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)
   }

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,6 +14,7 @@ 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 timeTracker: { start(): void, taken(): 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', () => {

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,5 +1,5 @@
-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(

package/src/assertron/repeat.spec.ts

@@ -1,5 +1,5 @@
 import a from '..'
-import { FailOnOccurance } from './repeat';
+import { FailOnOccurrence } from './repeat'
 
 test('repeat function n times', () => {
   let count = 0
@@ -28,22 +28,22 @@ test('error is captured as inner error and indicate which call failed', () => {
   const err = a.throws(() => a.repeat(() => {
     ++count
     if (count === 5) throw new Error('failed')
-  }, 10), FailOnOccurance)
+  }, 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
-  const 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')
 })

package/src/assertron/repeat.ts

@@ -17,7 +17,7 @@ function repeatRecur<R>(fn: () => R | (() => Promise<R>), i: number, times: numb
     if (isPromise(result)) {
       return result.then(
         () => repeatRecur(fn, i + 1, times),
-        (e) => { throw new FailOnOccurance(i, e) }
+        (e) => { throw new FailOnOccurrence(i, e) }
       ) as any
     }
     else {
@@ -25,13 +25,13 @@ function repeatRecur<R>(fn: () => R | (() => Promise<R>), i: number, times: numb
     }
   }
   catch (e) {
-    if (e instanceof FailOnOccurance) throw e
-    throw new FailOnOccurance(i, e)
+    if (e instanceof FailOnOccurrence) throw e
+    throw new FailOnOccurrence(i, e)
   }
 }
 
-export class FailOnOccurance extends AssertionError {
-  constructor(public occurance: number, public error: any) {
-    super(`Failed on ${occurance} occurance`)
+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,5 +1,5 @@
-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(

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)

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),

package/src/assertron/throws.spec.ts

@@ -1,7 +1,7 @@
-import t from 'assert';
-import AssertionError from 'assertion-error';
-import a from '..';
-import { assertAsyncThrows, assertIsError, assertIsPromise, assertThrows, noStackTraceFor } from '../testUtils';
+import t from 'assert'
+import AssertionError from 'assertion-error'
+import a from '..'
+import { assertAsyncThrows, assertIsError, assertIsPromise, assertThrows, noStackTraceFor } from '../testUtils'
 
 test('when value is PromiseLike returns Promise', async () => {
   let actual = a.throws(Promise.reject(new Error()), Error)
@@ -94,12 +94,16 @@ test('thrown error does not contain internal stack track if function does not',
 })
 
 test('throws if function returns resolved promise', async () => {
-  const err = await assertAsyncThrows<AssertionError<{ value: string }>>(() => a.throws(() => Promise.resolve('ok')), AssertionError)
+  const err = await assertAsyncThrows<AssertionError<{ value: string }>>(
+    () => a.throws(() => Promise.resolve('ok')),
+    AssertionError)
   t.strictEqual(err.value, 'ok')
 })
 
 test('thrown error does not contain internal stack trace if function returns resolved promise', async () => {
-  const err = await assertAsyncThrows<AssertionError<{ value: string }>>(() => a.throws(() => Promise.resolve('ok')), AssertionError)
+  const err = await assertAsyncThrows<AssertionError<{ value: string }>>(
+    () => a.throws(() => Promise.resolve('ok')),
+    AssertionError)
   noStackTraceFor('throws.ts', err)
 })
 
@@ -119,7 +123,10 @@ test('throws if function returns rejected promise not passing valdation', async
 })
 
 test('thrown error does not contain stack trace if function returns rejected promise not passing valdation', async () => {
-  const err = await assertAsyncThrows<AssertionError<{ actual: any }>>(() => a.throws(() => Promise.reject('ok'), err => err !== 'ok'))
+  const err = await assertAsyncThrows<
+    AssertionError<{ actual: any }>
+  >(() => a.throws(() => Promise.reject('ok'), err => err !== 'ok'))
+  // console.log('got err', err)
   noStackTraceFor('throws.ts', err)
 })
 

package/src/assertron/throws.ts

@@ -10,7 +10,7 @@ export function throws<T, R = any>(value: (...args: any[]) => R, validator?: Err
 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 functio n or promise.',
+      '`assertron.throws()` must be called with a function or promise.',
       undefined,
       throws
     )
@@ -81,11 +81,13 @@ function validateError(validator: ErrorValidator | ErrorConstructor<any> | undef
           throws
         )
     }
-    else if (!validator(error))
+    else if (!validator(error)) {
+      // console.log('msg:', unexpectedErrorMessage(error, validator))
       throw new AssertionError(
         unexpectedErrorMessage(error, validator),
         { actual: error, expected: validator },
         throws
       )
+    }
   }
 }

package/src/assertron/truthy.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'
 
 test('falsy statement throws', () => {
   assertThrows(() => a.truthy(false), AssertionError)

package/src/testUtils.ts

@@ -1,11 +1,13 @@
 // istanbul ignore file
-import t from 'assert';
-import AssertionError from 'assertion-error';
-import isPromise from 'is-promise';
-import { isError } from 'lodash';
-import { ErrorConstructor } from './errors';
+import t from 'assert'
+import AssertionError from 'assertion-error'
+import isPromise from 'is-promise'
+import { isError } from 'lodash'
+import { ErrorConstructor } from './errors'
 
-export function runAsync(fn) {
+export type AnyFunction = (...args: any[]) => any
+
+export function runAsync(fn: AnyFunction) {
   return new Promise((resolve, reject) => {
     setTimeout(() => {
       try {
@@ -18,7 +20,7 @@ export function runAsync(fn) {
   })
 }
 
-export function runSequentialAsync(...fns) {
+export function runSequentialAsync(...fns: AnyFunction[]) {
   return new Promise((resolve, reject) => {
     setTimeout(() => {
       try {
@@ -35,7 +37,7 @@ export function runSequentialAsync(...fns) {
   })
 }
 
-export function runParallelAsync(...fns) {
+export function runParallelAsync(...fns: AnyFunction[]) {
   return Promise.all(fns.map(fn => runAsync(fn)))
 }
 
@@ -48,11 +50,11 @@ export function assertIsError(err: Error) {
   t(isError(err))
 }
 
-export function assertThrows<E extends Error>(fn, ErrorType?: ErrorConstructor<E>): E {
+export function assertThrows<E extends Error>(fn: AnyFunction, ErrorType?: ErrorConstructor<E>): E {
   try {
     fn()
   }
-  catch (e) {
+  catch (e: any) {
     if (ErrorType && !(e instanceof ErrorType)) {
       throw new Error(`thrown error ${e} is not of expected type ${ErrorType}`)
     }
@@ -61,21 +63,23 @@ export function assertThrows<E extends Error>(fn, ErrorType?: ErrorConstructor<E
   throw new Error(`${fn} does not throw as expected`)
 }
 
-export async function assertAsyncThrows<E extends Error>(fn, ErrorType?: ErrorConstructor<E>): Promise<E> {
+export async function assertAsyncThrows<E extends Error>(fn: AnyFunction, ErrorType?: ErrorConstructor<E>): Promise<E> {
   try {
     await fn()
   }
-  catch (e) {
+  catch (e: any) {
+    // console.log('catch clause', e)
     if (ErrorType && !(e instanceof ErrorType)) {
       throw new Error(`thrown error ${e} is not of expected type ${ErrorType}`)
     }
+    // console.log('returning e')
     return e
   }
   throw new Error(`${fn} does not throw as expected`)
 }
 
 
-export function noStackTraceFor(filename: string, err: AssertionError) {
+export function noStackTraceFor(filename: string, err: AssertionError<any>) {
   if (err.stack && RegExp(filename).test(err.stack))
     throw new Error(`contains internal stack: \n${err.stack}`)
 }