Encourages programming with assertions by providing tools to compile them away.
See: "unassert - encourage reliable programming by writing assertions in production " -- talk at NodeFest 2015, and "One more thing..." in talk at NodeFest 2016, titled "From Library to Tool - power-assert as a General Purpose Assertion Enhancement Tool "
unassertify : Browserify transform for unassert
babel-plugin-unassert : Babel plugin for unassert
webpack-unassert-loader : Webpack loader for unassert
gulp-unassert : Gulp plugin for unassert
unassert-cli : CLI for unassert
INSTALL
$ npm install --save-dev unassert copy
EXAMPLE
For given math.js below,
const assert = require ( 'node:assert' );
function add (a, b) {
assert ( typeof a === 'number' );
console. assert ( ! isNaN (a));
assert. equal ( typeof b, 'number' );
assert. ok ( ! isNaN (b));
return a + b;
} copy
Apply unassertAst then generate modified code to console.
via CJS code
const { unassertAst } = require ( 'unassert' );
const { parse } = require ( 'acorn' );
const { generate } = require ( 'escodegen' );
const { readFileSync } = require ( 'node:fs' );
const { join, dirname } = require ( 'node:path' );
const filepath = join (__dirname, 'math.js' );
const ast = parse ( readFileSync (filepath), { ecmaVersion: '2022' });
const modifiedAst = unassertAst (ast);
console. log (
or via ESM code
import { unassertAst } from 'unassert' ;
import { parse } from 'acorn' ;
import { generate } from 'escodegen' ;
import { readFileSync } from 'node:fs' ;
import { join, dirname } from 'node:path' ;
import { fileURLToPath } from 'node:url' ;
const __dirname = dirname ( fileURLToPath ( import .meta.url));
const filepath = join (__dirname, 'math.js' );
const ast = parse ( readFileSync (filepath), { ecmaVersion: '2022' });
const modifiedAst =
Then you will see assert calls disappear.
function add (a, b) {
return a + b;
} copy
API
unassert package exports three functions. unassertAst is the main function. createVisitor and defaultOptions are for customization.
const modifiedAst = unassertAst(ast, options)
const { unassertAst } = require ( 'unassert' ) copy
import { unassertAst } from 'unassert' copy
Remove assertion calls from ast (ECMAScript AST ). Default behaviour can be customized by options. ast is manipulated directly so returned modifiedAst will be the same instance of ast.
options
Object for configuration options. passed options is Object.assigned with default options. If not passed, default options will be used.
options.modules
Target module names for assertion call removal.
For example, the default target modules are as follows.
{
modules : [
'assert' ,
'assert/strict' ,
'node:assert' ,
'node:assert/strict'
] copy
In this case, unassert will remove assert variable declarations such as,
import assert from "assert"
import assert from "assert/strict"
import assert from "node:assert"
import assert from "node:assert/strict"
import * as assert from "assert"
import * as assert from "node:assert"
import * as assert from "assert/strict"
import * as assert from "node:assert/strict"
import { strict as assert } from "assert"
import { strict as assert } from "node:assert"
import { default as assert } from "assert"
import { default as assert } from "node:assert"
const assert = require("assert")
const assert = require("node:assert")
const assert = require("assert/strict")
const assert = require("node:assert/strict")
const assert = require("assert").strict
const assert = require("node:assert").strict
const { strict: assert } = require("assert")
const { strict: assert } = require("node:assert")
and assignments.
assert = require("assert")
assert = require("node:assert")
assert = require("assert/strict")
assert = require("node:assert/strict")
assert = require("assert").strict
assert = require("node:assert").strict
In this default case, unassert will remove assertion calls such as,
assert(value, [message])
assert.ok(value, [message])
assert.equal(actual, expected, [message])
assert.notEqual(actual, expected, [message])
assert.strictEqual(actual, expected, [message])
assert.notStrictEqual(actual, expected, [message])
assert.deepEqual(actual, expected, [message])
assert.notDeepEqual(actual, expected, [message])
assert.deepStrictEqual(actual, expected, [message])
assert.notDeepStrictEqual(actual, expected, [message])
assert.match(string, regexp[, message])
assert.doesNotMatch(string, regexp[, message])
assert.throws(block, [error], [message])
assert.doesNotThrow(block, [message])
await assert.rejects(asyncFn, [error], [message])
await assert.doesNotReject(asyncFn, [error], [message])
assert.fail([message])
assert.fail(actual, expected, message, operator)
assert.ifError(value)
in addition, unassert removes console.assert calls as well.
console.assert(value, [message])
Auto Variable Tracking
unassert automatically removes assertion calls based on their imported variable names.
So if import declaration is as follows,
import strictAssert, { ok, equal as eq } from 'node:assert/strict';
unassert removes all strictAssert, ok, eq calls.
Please see customization example for more details.
const visitor = createVisitor(options)
const { createVisitor } = require ( 'unassert' ) copy
import { createVisitor } from 'unassert' copy
Create visitor object to be used with estraverse.replace. Visitor can be customized by options.
const options = defaultOptions()
const { defaultOptions } = require ( 'unassert' ) copy
import { defaultOptions } from 'unassert' copy
Returns default options object for unassertAst and createVisitor function. In other words, returns
{
modules : [
'assert' ,
'assert/strict' ,
'node:assert' ,
'node:assert/strict'
]
} copy
CUSTOMIZATION
You can customize options such as target module names.
{
modules : [
'node:assert' ,
'node:assert/strict' ,
'power-assert' ,
'invariant' ,
'nanoassert' ,
'uvu/assert'
]
} copy
example
For given custom.js below,
import invariant from 'invariant' ;
import nassert from 'nanoassert' ;
import * as uvuassert from 'uvu/assert' ;
import { strict as powerAssert } from 'power-assert' ;
import { default as looseAssert } from 'node:assert' ;
import strictAssert, { ok, equal as eq } from 'node:assert/strict' ;
async function add (a, b) {
strictAssert ( ! isNaN (a));
looseAssert ( typeof a === 'number' );
eq ( typeof
Apply unassertAst with customized options then generate modified code to console.
import { unassertAst } from 'unassert' ;
import { parse } from 'acorn' ;
import { generate } from 'escodegen' ;
import { readFileSync } from 'node:fs' ;
import { join, dirname } from 'node:path' ;
import { fileURLToPath } from 'node:url' ;
const __dirname = dirname ( fileURLToPath ( import .meta.url));
const filepath = join (__dirname, 'custom.js' );
const ast = parse ( readFileSync (filepath), { ecmaVersion: '2022' });
const modifiedAst =
Then you will see all assert calls disappear.
async function add (a, b) {
return a + b;
} copy
OUR SUPPORT POLICY
We support Node under maintenance. In other words, we stop supporting old Node version when their maintenance ends .
This means that any other environment is not supported.
NOTE: If unassert works in any of the unsupported environments, it is purely coincidental and has no bearing on future compatibility. Use at your own risk.
AUTHOR
CONTRIBUTORS
LICENSE
Licensed under the MIT license.