supertape 7.7.0 → 8.0.1

package/ChangeLog

@@ -1,3 +1,40 @@
+2022.09.07, v8.0.1
+
+feature:
+- package: @supertape/operator-stub v3.0.0
+- @supertape/operator-stub: type: Result -> OperationResult
+- (package) supertape v8.0.0
+
+2022.09.07, v8.0.0
+
+fix:
+- @supertape/formatter-short: drop support of node < 16
+- @supertape/formatter-tap: drop support of node < 16
+- @supertape/formatter-tap: get back commonjs, since @supertape/formatter-fail is commonjs
+
+feature:
+- package: @supertape/formatter-progress-bar v3.0.0
+- formatters: convert to ESM
+- supertape: add ability to use 'createFormatter()' to create formatters
+- @putout/formatter-progress-bar: convert to ESM
+- package: @supertape/formatter-fail v3.0.0
+- @supertape/formatter-json-lines: drop support of node < 16
+- @supertape/formatter-fail: drop support of node < 16
+- package: @supertape/formatter-tap v3.0.1
+- package: @supertape/formatter-json-lines v2.0.0
+- package: @supertape/formatter-short v2.0.0
+- package: @supertape/formatter-tap v3.0.0
+- @supertape/formatter-short: convert to ESM
+- @supertape/formatter-tap: convert to ESM
+- @supertape/formatter-json-lines: convert to ESM
+- supertape: add support of ESM formatters
+- supertape: actual -> result
+
+2022.08.29, v7.7.1
+
+feature:
+- package: jest-diff v29.0.1
+
 2022.08.28, v7.7.0
 
 feature:

package/README.md

@@ -1,37 +1,43 @@
-# 📼 Supertape [![NPM version][NPMIMGURL]][NPMURL] [![Build Status][BuildStatusIMGURL]][BuildStatusURL] [![Coverage Status][CoverageIMGURL]][CoverageURL]
+# 📼 Supertape [![NPM version][NPMIMGURL]][NPMURL] [![Build Status][BuildStatusIMGURL]][BuildStatusURL] [![Coverage Status][CoverageIMGURL]][CoverageURL] [![License: MIT][MITLicenseIMGURL]][MITLicenseURL]
 
 [NPMURL]: https://npmjs.org/package/supertape "npm"
 [NPMIMGURL]: https://img.shields.io/npm/v/supertape.svg?style=flat&longCache=true
-[BuildStatusURL]: https://github.com/coderaiser/putout/actions?query=workflow%3A%22Node+CI%22 "Build Status"
-[BuildStatusIMGURL]: https://github.com/coderaiser/putout/workflows/Node%20CI/badge.svg
+[BuildStatusURL]: https://github.com/coderaiser/supertape/actions?query=workflow%3A%22Node+CI%22 "Build Status"
+[BuildStatusIMGURL]: https://github.com/coderaiser/supertape/workflows/Node%20CI/badge.svg
 [BuildStatusURL]: https://travis-ci.org/coderaiser/supertape "Build Status"
 [CoverageURL]: https://coveralls.io/github/coderaiser/supertape?branch=master
 [CoverageIMGURL]: https://coveralls.io/repos/coderaiser/supertape/badge.svg?branch=master&service=github
+[MITLicenseURL]: https://opensource.org/licenses/MIT
+[MITLicenseIMGURL]: https://img.shields.io/badge/License-MIT-green.svg
 
 [![supertape](https://asciinema.org/a/Cgc3rDOfZAeDnJSxzEYpPfBMY.svg)](https://asciinema.org/a/Cgc3rDOfZAeDnJSxzEYpPfBMY)
 
-[Tape](https://github.com/substack/tape)-inspired [TAP](https://testanything.org/)-compatible simplest high speed test runner with superpowers.
+[**Tape**](https://github.com/substack/tape)-inspired [`TAP`](https://testanything.org/)-compatible simplest high speed test runner with superpowers.
 
-📼`Supertape` written from scratch after messing a lot with `tape`, it willing to be compatible with it as much as possible.
-and has a couple differences. It contains:
+📼 **Supertape** is a fast, minimal test runner with the soul of **tape**. It's designed to be as compatible as possible with **tape** while still having some key improvements, such as:
 
-- ability to work with [esm modules](https://nodejs.org/api/esm.html) (take a look at [mock-import](https://github.com/coderaiser/mock-import) for mocking).
-- shows colored diff when test not `equal` or not `deepEqual`;
-- produces deteiled stack traces for `async functions`;
-- as many `only` as you wish;
-- ability to extend;
-- smart timeouts for long running tests 🏃‍♂️(configured with `SUPERTAPE_TIMEOUT`);
-- more natural assertions: `expected, result` -> `result, expected`, for example:
+- the ability to work with [ESM Modules](https://nodejs.org/api/esm.html) (take a look at [mock-import](https://github.com/coderaiser/mock-import) for mocking and 🎩[ESCover](https://github.com/coderaiser/escover) for coverage)
+- a number of [built-in pretty output formatters](#formatting)
+- easy [configuration](#list-of-options)
+- the ability to [extend](#extending)
+- showing colored diff when using the [`t.equal()`](#tequalresult-any-expected-any-message-string) and [`t.deepEqual()`](#tdeepequalresult-any-expected-any-message-string) assertion operators
+- detailed stack traces for `async` functions
+- multiple [`test.only`'s](#testonlymessage-string-fn-t-test--void-options-testoptions)
+- [smart timeouts](#supertape_timeout) for long running tests 🏃‍♂️
+- more natural assertions: `expected, result` -> `result, expected`:
 
-```js
-t.equal(error.message, 'hello world', `expected error.message to be 'hello world'`);
-```
+  ```js
+  t.equal(error.message, 'hello world', `expected error.message to be 'hello world'`);
+  ```
+
+📼 **Supertape** doesn't contain:
 
-Doesn't contain:
+- assertion aliases, making the available operators far more concise
+- `es3 code` and lot's of [ponyfills](https://github.com/sindresorhus/ponyfill#how-are-ponyfills-better-than-polyfills)
+- `t.throws()`, `t.doesNotThrow()` - use [**tryCatch**](https://github.com/coderaiser/try-catch) or [**tryToCatch**](https://github.com/coderaiser/try-to-catch) with [`t.equal()`](#tequalresult-any-expected-any-message-string) instead
+- [`t.plan()`](https://github.com/substack/tape#tplann)
 
-- `es3 code` and lot's of [ponyfills](https://github.com/sindresorhus/ponyfill#how-are-ponyfills-better-than-polyfills).
-- aliases, methods list much shorter;
-- `throws`, `doesNotThrows` - use [tryCatch](https://github.com/coderaiser/try-catch), [tryToCatch](https://github.com/coderaiser/try-to-catch) with `equal` instead.
+For a list of all built-in assertions, see [Operators](#operators).
 
 ## Install
 
@@ -84,7 +90,73 @@ Here is [result example](https://github.com/coderaiser/cloudcmd/commit/74d56f795
 
 ## Operators
 
-To simplify `supertape` core operators located in separate packages, called `operators`:
+The assertion methods of 📼 **Supertape** are heavily influenced by [**tape**](https://github.com/substack/tape). However, to keep a minimal core of assertions, there are no aliases and some superfluous operators have been removed (such as `t.throws()`).
+
+The following is a list of the base methods maintained by 📼 **Supertape**. Others, such as assertions for stubbing, are maintained in [separate packages](#other-built-in-operators). To add custom assertion operators, see [Extending](#extending).
+
+### Core Operators
+
+#### `t.equal(result: any, expected: any, message?: string)`
+
+Asserts that `result` and `expected` are strictly equal. If `message` is provided, it will be outputted as a description of the assertion.
+
+*Note: uses `Object.is(result, expected)`*
+
+#### `t.notEqual(result: any, expected: any, message?: string)`
+
+Asserts that `result` and `expected` are not strictly equal. If `message` is provided, it will be outputted as a description of the assertion.
+
+*Note: uses `!Object.is(result, expected)`*
+
+#### `t.deepEqual(result: any, expected: any, message?: string)`
+
+Asserts that `result` and `expected` are loosely equal, with the same structure and nested values. If `message` is provided, it will be outputted as a description of the assertion.
+
+*Note: uses [node's deepEqual() algorithm][NodeDeepEqual] with strict comparisons (`===`) on leaf nodes*
+
+#### `t.notDeepEqual(result: any, expected: any, message?: string)`
+
+Asserts that `result` and `expected` not loosely equal, with different structure and/or nested values. If `message` is provided, it will be outputted as a description of the assertion.
+
+*Note: uses [node's deepEqual() algorithm][NodeDeepEqual] with strict comparisons (`===`) on leaf nodes*
+
+[NodeDeepEqual]: https://github.com/substack/node-deep-equal
+
+#### `t.ok(result: boolean | any, message?: string)`
+
+Asserts that `result` is truthy. If `message` is provided, it will be outputted as a description of the assertion.
+
+#### `t.notOk(result: boolean | any, message?: string)`
+
+Asserts that `result` is falsy. If `message` is provided, it will be outputted as a description of the assertion.
+
+#### `t.pass(message: string)`
+
+Generates a passing assertion with `message` as a description.
+
+#### `t.fail(message: string)`
+
+Generates a failing assertion with `message` as a description.
+
+#### `t.end()`
+
+Declares the end of a test explicitly. Must be called exactly once per test. (See: [Single Call to `t.end()`](#single-call-to-tend))
+
+#### `t.match(result: string, pattern: string | RegExp, message?: string)`
+
+Asserts that `result` matches the regex `pattern`. If `pattern` is not a valid regex, the assertion fails. If `message` is provided, it will be outputted as a description of the assertion.
+
+#### `t.notMatch(result: string, pattern: string | RegExp, message?: string)`
+
+Asserts that `result` does not match the regex `pattern`. If `pattern` is not a valid regex, the assertion always fails. If `message` is provided, it will be outputted as a description of the assertion.
+
+#### `t.comment(message: string)`
+
+Print a message without breaking the `TAP` output. Useful when using a `tap`-reporter such as `tap-colorize`, where the output is buffered and `console.log()` will print in incorrect order vis-a-vis `TAP` output.
+
+### Special Operators
+
+To simplify the core of 📼 **Supertape**, other operators are maintained in separate packages. The following is a list of all such packages:
 
 Here is a list of built-int operators:
 
@@ -196,31 +268,31 @@ Assert that `value` is truthy with an optional description of the assertion `msg
 
 Assert that `value` is falsy with an optional description of the assertion `msg`.
 
-## t.match(actual, pattern[, msg])
+## t.match(result, pattern[, msg])
 
-Assert that `pattern: string | regexp` matches `actual` with an optional description of the assertion `msg`.
+Assert that `pattern: string | regexp` matches `result` with an optional description of the assertion `msg`.
 
-## t.notMatch(actual, pattern[, msg])
+## t.notMatch(result, pattern[, msg])
 
-Assert that `pattern: string | regexp`  not matches `actual` with an optional description of the assertion `msg`.
+Assert that `pattern: string | regexp`  not matches `result` with an optional description of the assertion `msg`.
 
-## t.equal(actual, expected, msg)
+## t.equal(result, expected, msg)
 
-Assert that `Object.is(actual, expected)` with an optional description of the assertion `msg`.
+Assert that `Object.is(result, expected)` with an optional description of the assertion `msg`.
 
-## t.notEqual(actual, expected, msg)
+## t.notEqual(result, expected, msg)
 
-Assert that `!Object.is(actual, expected)` with an optional description of the assertion `msg`.
+Assert that `!Object.is(result, expected)` with an optional description of the assertion `msg`.
 
-## t.deepEqual(actual, expected, msg)
+## t.deepEqual(result, expected, msg)
 
-Assert that `actual` and `expected` have the same structure and nested values using
+Assert that `result` and `expected` have the same structure and nested values using
 [node's deepEqual() algorithm](https://github.com/substack/node-deep-equal)
 with strict comparisons (`===`) on leaf nodes and an optional description of the assertion `msg`.
 
-## t.notDeepEqual(actual, expected, msg)
+## t.notDeepEqual(result, expected, msg)
 
-Assert that `actual` and `expected` do not have the same structure and nested values using
+Assert that `result` and `expected` do not have the same structure and nested values using
 [node's deepEqual() algorithm](https://github.com/substack/node-deep-equal)
 with strict comparisons (`===`) on leaf nodes and an optional description of the assertion `msg`.
 

package/lib/cli.js

@@ -169,7 +169,9 @@ async function cli({argv, cwd, stdout, isStop}) {
         checkAssertionsCount,
     });
     
-    supertape.createStream().pipe(stdout);
+    const stream = await supertape.createStream();
+    
+    stream.pipe(stdout);
     
     const promises = [];
     const files = removeDuplicates(allFiles);

package/lib/formatter/harness.js

@@ -40,7 +40,7 @@ function prepare(reporter) {
         success: stub,
         comment: stub,
         end: stub,
-        ...reporter,
+        ...reporter.createFormatter?.() || reporter,
     });
     
     return result;

package/lib/formatter/index.js

@@ -3,11 +3,12 @@
 const {EventEmitter} = require('events');
 const {createHarness} = require('./harness');
 
-const resolveFormatter = (name) => require(`@supertape/formatter-${name}`);
+const resolveFormatter = async (name) => await import(`@supertape/formatter-${name}`);
+const isString = (a) => typeof a === 'string';
 
-module.exports.createFormatter = (name) => {
+module.exports.createFormatter = async (name) => {
     const formatter = new EventEmitter();
-    const harness = createHarness(resolveFormatter(name));
+    const harness = createHarness(!isString(name) ? name : await resolveFormatter(name));
     
     formatter.on('start', ({total}) => {
         harness.write({
@@ -48,14 +49,14 @@ module.exports.createFormatter = (name) => {
         });
     });
     
-    formatter.on('test:fail', ({at, count, message, operator, actual, expected, output, errorStack}) => {
+    formatter.on('test:fail', ({at, count, message, operator, result, expected, output, errorStack}) => {
         harness.write({
             type: 'fail',
             at,
             count,
             message,
             operator,
-            actual,
+            result,
             expected,
             output,
             errorStack,

package/lib/operators.mjs

@@ -16,17 +16,17 @@ const isObj = (a) => typeof a === 'object';
 
 const end = () => {};
 
-const ok = (actual, message = 'should be truthy') => ({
-    is: Boolean(actual),
+const ok = (result, message = 'should be truthy') => ({
+    is: Boolean(result),
     expected: true,
-    actual,
+    result,
     message,
 });
 
-const notOk = (actual, message = 'should be falsy') => ({
-    is: !actual,
+const notOk = (result, message = 'should be falsy') => ({
+    is: !result,
     expected: false,
-    actual: actual && stringify(actual),
+    result: result && stringify(result),
     message,
 });
 
@@ -42,56 +42,56 @@ const validateRegExp = (regexp) => {
 
 const {stringify} = JSON;
 
-function match(actual, regexp, message = 'should match') {
+function match(result, regexp, message = 'should match') {
     const error = validateRegExp(regexp);
     
     if (error)
         return fail(error);
     
-    const is = maybeRegExp(regexp).test(actual);
+    const is = maybeRegExp(regexp).test(result);
     
     return {
         is,
-        actual,
+        result,
         expected: regexp,
         message,
     };
 }
 
-function notMatch(actual, regexp, message = 'should not match') {
-    const {is} = match(actual, regexp, message);
+function notMatch(result, regexp, message = 'should not match') {
+    const {is} = match(result, regexp, message);
     
     return {
         is: !is,
-        actual,
+        result,
         expected: regexp,
         message,
     };
 }
 
-function equal(actual, expected, message = 'should equal') {
+function equal(result, expected, message = 'should equal') {
     let output = '';
-    const is = Object.is(actual, expected);
+    const is = Object.is(result, expected);
     
     if (!is)
-        output = diff(expected, actual) || '    result: values not equal, but deepEqual';
+        output = diff(expected, result) || '    result: values not equal, but deepEqual';
     
     return {
         is,
-        actual,
+        result,
         expected,
         message,
         output,
     };
 }
 
-function notEqual(actual, expected, message = 'should not equal') {
-    const is = !Object.is(actual, expected);
-    const output = is ? '' : diff(expected, actual);
+function notEqual(result, expected, message = 'should not equal') {
+    const is = !Object.is(result, expected);
+    const output = is ? '' : diff(expected, result);
     
     return {
         is,
-        actual,
+        result,
         expected,
         message,
         output,
@@ -112,26 +112,26 @@ const fail = (error, at) => ({
     at,
 });
 
-const deepEqual = (actual, expected, message = 'should deep equal') => {
-    const is = deepEqualCheck(actual, expected);
-    const output = is ? '' : diff(expected, actual);
+const deepEqual = (result, expected, message = 'should deep equal') => {
+    const is = deepEqualCheck(result, expected);
+    const output = is ? '' : diff(expected, result);
     
     return {
         is: is || !output,
-        actual,
+        result,
         expected,
         message,
         output,
     };
 };
 
-const notDeepEqual = (actual, expected, message = 'should not deep equal') => {
-    const is = !deepEqualCheck(actual, expected);
-    const output = is ? '' : diff(expected, actual);
+const notDeepEqual = (result, expected, message = 'should not deep equal') => {
+    const is = !deepEqualCheck(result, expected);
+    const output = is ? '' : diff(expected, result);
     
     return {
         is,
-        actual,
+        result,
         expected,
         message,
         output,
@@ -245,7 +245,7 @@ function run(name, {formatter, count, incCount, incPassed, incFailed}, testState
         is,
         message,
         expected,
-        actual,
+        result,
         output,
         stack,
         at,
@@ -272,7 +272,7 @@ function run(name, {formatter, count, incCount, incPassed, incFailed}, testState
         count: count(),
         message,
         operator: name,
-        actual,
+        result,
         expected,
         output,
         errorStack: formatOutput(errorStack),

package/lib/supertape.d.ts

@@ -5,30 +5,30 @@ import {
     Stub,
 } from '@cloudcmd/stub';
 
-type Result = {
+type OperationResult = {
     is: boolean,
     expected: unknown,
-    actual: unknown,
+    result: unknown,
     message: string,
     output: string,
 };
 
 type Operator = {
-    [index: string]: (...args: any[]) => Result
+    [index: string]: (...args: any[]) => OperationResult;
 };
 
 type Test = Operator & OperatorStub & {
-    equal: (result: unknown, expected: unknown, message?: string) => Result;
-    notEqual: (result: unknown, expected: unknown, message?: string) => Result;
-    deepEqual: (result: unknown, expected: unknown, message?: string) => Result;
-    notDeepEqual: (result: unknown, expected: unknown, message?: string) => Result;
-    fail: (message: string) => Result;
-    pass: (message: string) => Result;
-    ok: (result: boolean | unknown, message?: string) => Result;
-    comment: (message: string) => Result;
-    notOk: (result: boolean | unknown, message?: string) => Result;
-    match: (result: string, pattern: string | RegExp, message?: string) => Result;
-    notMatch: (result: string, pattern: string | RegExp, message?: string) => Result;
+    equal: (result: unknown, expected: unknown, message?: string) => OperationResult;
+    notEqual: (result: unknown, expected: unknown, message?: string) => OperationResult;
+    deepEqual: (result: unknown, expected: unknown, message?: string) => OperationResult;
+    notDeepEqual: (result: unknown, expected: unknown, message?: string) => OperationResult;
+    fail: (message: string) => OperationResult;
+    pass: (message: string) => OperationResult;
+    ok: (result: boolean | unknown, message?: string) => OperationResult;
+    comment: (message: string) => OperationResult;
+    notOk: (result: boolean | unknown, message?: string) => OperationResult;
+    match: (result: string, pattern: string | RegExp, message?: string) => OperationResult;
+    notMatch: (result: string, pattern: string | RegExp, message?: string) => OperationResult;
     end: () => void;
 };
 
@@ -47,7 +47,7 @@ declare namespace test {
 export default test;
 
 type CustomOperator = {
-    [index: string]: (operator: Operator) => (...args: any[]) => Result
+    [index: string]: (operator: Operator) => (...args: any[]) => OperationResult
 };
 
 declare function extend(customOperator: CustomOperator): typeof test;

package/lib/supertape.js

@@ -1,13 +1,16 @@
 'use strict';
 
 const {EventEmitter} = require('events');
+const {PassThrough} = require('stream');
+
 const once = require('once');
 
 const options = require('../supertape.json');
 
 const {getAt, setValidations} = require('./validator');
 const runTests = require('./run-tests');
-const createFormatter = once(require('./formatter').createFormatter);
+const _createFormatter = require('./formatter').createFormatter;
+const createFormatter = once(_createFormatter);
 
 const createEmitter = once(_createEmitter);
 
@@ -38,7 +41,7 @@ const defaultOptions = {
     checkScopes: true,
 };
 
-function _createEmitter({quiet, format, getOperators, isStop}) {
+function _createEmitter({quiet, stream = stdout, format, getOperators, isStop, readyFormatter}) {
     const tests = [];
     const emitter = new EventEmitter();
     
@@ -62,10 +65,10 @@ function _createEmitter({quiet, format, getOperators, isStop}) {
     });
     
     emitter.on('run', async () => {
-        const {harness, formatter} = createFormatter(format);
+        const {harness, formatter} = readyFormatter || await createFormatter(format);
         
         if (!quiet)
-            harness.pipe(stdout);
+            harness.pipe(stream);
         
         const operators = await getOperators();
         const result = await runTests(tests, {
@@ -90,14 +93,45 @@ module.exports.init = (options) => {
     assign(initedOptions, options);
 };
 
-const createStream = () => {
+const createStream = async () => {
     const {format} = initedOptions;
-    const {harness} = createFormatter(format);
+    const {harness} = await createFormatter(format);
     
     return harness;
 };
 
 module.exports.createStream = createStream;
+module.exports.createTest = async (testOptions = {}) => {
+    const {format = 'tap', formatter} = testOptions;
+    const readyFormatter = await _createFormatter(formatter || format);
+    
+    const stream = new PassThrough();
+    const emitter = _createEmitter({
+        ...defaultOptions,
+        ...testOptions,
+        readyFormatter,
+        stream,
+    });
+    
+    const fn = (message, fn, options = {}) => {
+        return test(message, fn, {
+            ...testOptions,
+            ...options,
+            emitter,
+        });
+    };
+    
+    assign(fn, {
+        stream,
+        ...test,
+        test: fn,
+        run: () => {
+            emitter.emit('run');
+        },
+    });
+    
+    return fn;
+};
 
 function test(message, fn, options = {}) {
     const {
@@ -130,7 +164,7 @@ function test(message, fn, options = {}) {
     
     const at = getAt();
     
-    const emitter = createEmitter({
+    const emitter = options.emitter || createEmitter({
         format,
         quiet,
         getOperators,

package/lib/supertape.mjs

@@ -1,6 +1,13 @@
 import test from './supertape.js';
 
-const {extend, stub} = test;
+const {
+    extend,
+    stub,
+    createStream,
+    init,
+    run,
+    createTest,
+} = test;
 
 export default test;
 
@@ -8,4 +15,8 @@ export {
     extend,
     test,
     stub,
+    createStream,
+    init,
+    run,
+    createTest,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supertape",
-  "version": "7.7.0",
+  "version": "8.0.1",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "📼 Supertape simplest high speed test runner with superpowers",
   "homepage": "http://github.com/coderaiser/supertape",
@@ -44,17 +44,17 @@
     "@putout/cli-keypress": "^1.0.0",
     "@putout/cli-validate-args": "^1.0.1",
     "@supertape/engine-loader": "^1.0.0",
-    "@supertape/formatter-fail": "^2.0.0",
-    "@supertape/formatter-json-lines": "^1.0.0",
-    "@supertape/formatter-progress-bar": "^2.0.0",
-    "@supertape/formatter-short": "^1.0.0",
-    "@supertape/formatter-tap": "^2.0.0",
-    "@supertape/operator-stub": "^2.0.0",
+    "@supertape/formatter-fail": "^3.0.0",
+    "@supertape/formatter-json-lines": "^2.0.0",
+    "@supertape/formatter-progress-bar": "^3.0.0",
+    "@supertape/formatter-short": "^2.0.0",
+    "@supertape/formatter-tap": "^3.0.0",
+    "@supertape/operator-stub": "^3.0.0",
     "cli-progress": "^3.8.2",
     "deep-equal": "^2.0.3",
     "fullstore": "^3.0.0",
     "glob": "^8.0.3",
-    "jest-diff": "^28.1.1",
+    "jest-diff": "^29.0.1",
     "once": "^1.4.0",
     "resolve": "^1.17.0",
     "stacktracey": "^2.1.7",
@@ -79,7 +79,7 @@
     "c8": "^7.3.5",
     "check-dts": "^0.6.5",
     "eslint": "^8.0.0",
-    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-n": "^15.2.5",
     "eslint-plugin-putout": "^16.0.1",
     "find-up": "^6.3.0",
     "madrun": "^9.0.0",