poku 1.2.0 → 1.3.0

package/README.md

@@ -38,23 +38,41 @@ A flexible and easy-to-use **Test Runner** for [Node.js][node-version-url], [Bun
 - No need to compile **TypeScript**
 - Compatible with **Coverage** tools
 - Allows both **in-code** and **CLI** usage
+- [**Node.js**][node-version-url], [**Bun**][bun-version-url] and [**Deno**][deno-version-url] compatibility
 - Zero configurations, except you want
 - No constraints or rules, code in your own signature style
 
 ---
 
-- Totally **dependency-free**
+- <img src="https://img.shields.io/bundlephobia/min/poku?label=Final%20Size">
+- **Zero** external dependencies
 - **Poku** dive to the deepest depths to find tests in the specified directories
 - **Compatibility:** **Poku** is tested across all **Node 6+**, **Bun 0.5.3+** and **Deno 1.30+** versions
 - **Poku** uses itself to test its own tests using `process.exit` at several depths on the same process node
 
 ---
 
-```bash
-  npx poku --include='test/unit,test/integration'
+| Sequential                                                   | Parallel                                                   |
+| ------------------------------------------------------------ | ---------------------------------------------------------- |
+| `npx poku test/unit,test/integration`                        | `npx poku --parallel test/unit,test/integration`           |
+| <img src=".github/assets/readme/sequential.png" width="360"> | <img src=".github/assets/readme/parallel.png" width="360"> |
+
+- By default, **Poku** searches for all _`.test.`_ files, but you can customize it using the option [`filter`](https://github.com/wellwelwel/poku#filter-rexexp).
+- The same idea for [**Bun**][bun-version-url] and [**Deno**][deno-version-url] (see bellow).
+
+---
+
+**Poku** also includes the `assert` method, keeping everything as it is, but providing human readability:
+
+```ts
+import { assert } from 'poku'; // Node and Bun
+import { assert } from 'npm:poku'; // Deno
+
+assert(true);
+assert.deepStrictEqual(1, '1', 'My optional custom message');
 ```
 
-<img src="./.github/assets/readme/screen-recording-2024-02-17-at-23.38.06.gif" width="360">
+> <img src=".github/assets/readme/assert.png" width="468" />
 
 ---
 
@@ -113,7 +131,7 @@ import { poku } from 'npm:poku';
 ```ts
 import { poku } from 'poku';
 
-await poku(['./a', './b']);
+await poku(['targetDirA', 'targetDirB']);
 ```
 
 > <img src=".github/assets/readme/deno.svg" width="24" />
@@ -121,7 +139,7 @@ await poku(['./a', './b']);
 ```ts
 import { poku } from 'npm:poku';
 
-await poku(['./a', './b']);
+await poku(['targetDirA', 'targetDirB']);
 ```
 
 ### CLI
@@ -129,19 +147,19 @@ await poku(['./a', './b']);
 > <img src=".github/assets/readme/node-js.svg" width="24" />
 
 ```bash
-npx poku --include='./a,./b'
+npx poku targetDirA,targetDirB
 ```
 
 > <img src=".github/assets/readme/bun.svg" width="24" />
 
 ```bash
-bun poku --include='./a,./b'
+bun poku targetDirA,targetDirB
 ```
 
 > <img src=".github/assets/readme/deno.svg" width="24" />
 
 ```bash
-deno run npm:poku --include='./a,./b'
+deno run npm:poku targetDirA,targetDirB
 ```
 
 ---
@@ -156,20 +174,40 @@ deno run npm:poku --include='./a,./b'
 
 #### Include directories
 
+- **in-code**
+
 ```ts
-poku('./targetDir');
+poku('targetDir');
 ```
 
 ```ts
-poku(['./targetDirA', './targetDirB']);
+poku(['targetDirA', 'targetDirB']);
+```
+
+- **CLI**
+
+By setting the directories as the last argument:
+
+> _Since **1.3.0**_
+
+```bash
+npx poku targetDir
 ```
 
 ```bash
-npx poku --include='./targetDir'
+npx poku targetDirA,targetDirB
+```
+
+By using `--include` option:
+
+> _Since **1.0.0**_
+
+```bash
+npx poku --include='targetDir'
 ```
 
 ```bash
-npx poku --include='./targetDirA,./targetDirB'
+npx poku --include='targetDirA,targetDirB'
 ```
 
 ---
@@ -211,7 +249,7 @@ poku(['...'], {
 ```bash
 # Parallel mode
 
-npx poku --include='...' --parallel
+npx poku --parallel ./test
 ```
 
 ---
@@ -261,23 +299,25 @@ poku('...', {
 ```bash
 # Normal
 
-npx poku   --include='...' --platform=node
-bun poku   --include='...' --platform=bun
-deno poku  --include='...' --platform=deno
+npx      poku      --platform=node  ./test
+bun      poku      --platform=bun   ./test
+deno run npm:poku  --platform=deno  ./test
 ```
 
 ```bash
 # Custom
+# When you're developing using a platform, but maintain compatibility with others
+
+npx      poku      --platform=bun   ./test
+bun      poku      --platform=deno  ./test
+deno run npm:poku  --platform=node  ./test
 
-npx poku       --include='...' --platform=bun
-bun poku       --include='...' --platform=deno
-deno run poku  --include='...' --platform=node
 # ...
 ```
 
 ---
 
-#### `filter: RexExp`
+#### `filter: RegExp`
 
 By default, **Poku** searches for _`.test.`_ files, but you can customize it using the `filter` option.
 
@@ -303,7 +343,7 @@ poku(['...'], {
  */
 
 poku(['...'], {
-  filter: /\.(m)?(j|t)?s$/,
+  filter: /\.(m)?(j|t)s$/,
   // filter: /\.(js|ts|mjs|mts)$/,
 });
 ```
@@ -313,19 +353,19 @@ poku(['...'], {
 ```bash
 # Testing only a specific file
 
-npx poku --include='...' --filter='some-file'
+npx poku --filter='some-file' ./test
 ```
 
 ```bash
 # Testing only a specific file
 
-npx poku --include='...' --filter='some-file|other-file'
+npx poku --filter='some-file|other-file' ./test
 ```
 
 ```bash
 # Testing only paths that contains "unit"
 
-npx poku --include='...' --filter='unit'
+npx poku --filter='unit' ./test
 ```
 
 - **Environment Variable**
@@ -335,24 +375,24 @@ npx poku --include='...' --filter='unit'
 ```bash
 # Testing only a specific file
 
-FILTER='some-file' npx poku --include='...'
+FILTER='some-file' npx poku ./test
 ```
 
 ```bash
 # Testing only a specific file
 
-FILTER='some-file|other-file' npx poku --include='...'
+FILTER='some-file|other-file' npx poku ./test
 ```
 
 ```bash
 # Testing only paths that contains "unit"
 
-FILTER='unit' npx poku --include='...'
+FILTER='unit' npx poku ./test
 ```
 
 ---
 
-#### `exclude: RexExp | RexExp[]`
+#### `exclude: RegExp | RegExp[]`
 
 > Exclude by path using Regex to match only the files that should be performed.
 >
@@ -425,17 +465,50 @@ poku(['...'], {
 ```bash
 # Excluding directories and files from tests
 
-npx poku --include='...' --exclude='some-file-or-dir'
+npx poku --exclude='some-file-or-dir' ./test
 ```
 
 ```bash
 # Excluding directories and files from tests
 
-npx poku --include='...' --exclude='some-file-or-dir|other-file-or-dir'
+npx poku --exclude='some-file-or-dir|other-file-or-dir' ./test
 ```
 
 ---
 
+### Assert
+
+> _Since **1.3.0**_
+>
+> [**Node.js**][node-version-url], [**Bun**][bun-version-url] and [**Deno**][deno-version-url] compatible.
+
+**Poku** includes the `assert` method, keeping everything as it is, but providing human readability.
+
+**Available methods:**
+
+- `assert(value[, message])`
+- `assert.deepEqual(actual, expected[, message])`
+- `assert.deepStrictEqual(actual, expected[, message])`
+- `assert.doesNotMatch(string, regexp[, message])`
+- `assert.doesNotReject(asyncFn[, error][, message])`
+- `assert.doesNotThrow(fn[, error][, message])`
+- `assert.equal(actual, expected[, message])`
+- `assert.fail([message])`
+- `assert.ifError(value)`
+- `assert.match(string, regexp[, message])`
+- `assert.notDeepEqual(actual, expected[, message])`
+- `assert.notDeepStrictEqual(actual, expected[, message])`
+- `assert.notEqual(actual, expected[, message])`
+- `assert.notStrictEqual(actual, expected[, message])`
+- `assert.ok(value[, message])`
+- `assert.rejects(asyncFn[, error][, message])`
+- `assert.strictEqual(actual, expected[, message])`
+- `assert.throws(fn[, error][, message])`
+
+You can follow the [**assert documentation**](https://nodejs.org/api/assert.html) from **Node.js**'s documentation.
+
+---
+
 ### `listFiles(targetDir: string, configs?: ListFilesConfigs)`
 
 > _Since **1.2.0**_

package/lib/bin/index.js

@@ -1,12 +1,14 @@
 #! /usr/bin/env node
 "use strict";
-var _a;
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 const list_files_js_1 = require("../modules/list-files.js");
 const get_arg_js_1 = require("../helpers/get-arg.js");
 const index_js_1 = require("../index.js");
 const get_runtime_js_1 = require("../helpers/get-runtime.js");
-const dirs = ((_a = (0, get_arg_js_1.getArg)('include')) === null || _a === void 0 ? void 0 : _a.split(',')) || [];
+const dirs = ((0, get_arg_js_1.hasArg)('include')
+    ? (_a = (0, get_arg_js_1.getArg)('include')) === null || _a === void 0 ? void 0 : _a.split(',')
+    : (_b = (0, get_arg_js_1.getLastParam)()) === null || _b === void 0 ? void 0 : _b.split(',')) || [];
 const platform = (0, get_arg_js_1.getArg)('platform');
 const filter = (0, get_arg_js_1.getArg)('filter');
 const parallel = (0, get_arg_js_1.hasArg)('parallel');

package/lib/helpers/format.d.ts

@@ -1,5 +1,6 @@
 export declare const format: {
     counter: (current: number, total: number, pad?: string) => string;
+    dim: (value: string) => string;
     bold: (value: string) => string;
     underline: (value: string) => string;
     info: (value: string) => string;

package/lib/helpers/format.js

@@ -7,6 +7,7 @@ exports.format = {
         const totalDigits = String(total).length;
         return (0, pad_js_1.padStart)(String(current), totalDigits, pad);
     },
+    dim: (value) => `\x1b[2m${value}\x1b[0m`,
     bold: (value) => `\x1b[1m${value}\x1b[0m`,
     underline: (value) => `\x1b[4m${value}\x1b[0m`,
     info: (value) => `\x1b[36m${value}\x1b[0m`,

package/lib/helpers/get-arg.d.ts

@@ -1,2 +1,3 @@
 export declare const getArg: (arg: string) => string | undefined;
 export declare const hasArg: (arg: string) => boolean;
+export declare const getLastParam: () => string;

package/lib/helpers/get-arg.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasArg = exports.getArg = void 0;
+exports.getLastParam = exports.hasArg = exports.getArg = void 0;
 const node_process_1 = __importDefault(require("process"));
 const [, , ...args] = node_process_1.default.argv;
 const getArg = (arg) => {
@@ -16,3 +16,7 @@ const getArg = (arg) => {
 exports.getArg = getArg;
 const hasArg = (arg) => args.some((a) => a.startsWith(`--${arg}`));
 exports.hasArg = hasArg;
+const getLastParam = () => {
+    return args[args.length - 1];
+};
+exports.getLastParam = getLastParam;

package/lib/helpers/hr.js

@@ -8,7 +8,7 @@ const node_os_1 = require("os");
 const node_process_1 = __importDefault(require("process"));
 const hr = () => {
     const columns = node_process_1.default.stdout.columns;
-    const line = '_'.repeat(columns - 10 || 0);
+    const line = '_'.repeat(columns - 10 || 30);
     console.log(`\x1b[2m${line}\x1b[0m${node_os_1.EOL}`);
 };
 exports.hr = hr;

package/lib/helpers/parseAsssetion.d.ts

@@ -0,0 +1,9 @@
+export type ParseAssertionOptions = {
+    message?: string | Error;
+    defaultMessage?: string;
+    actual?: string;
+    expected?: string;
+    throw?: boolean;
+    hideDiff?: boolean;
+};
+export declare const parseAssertion: (cb: () => void, options: ParseAssertionOptions) => void;

package/lib/helpers/parseAsssetion.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAssertion = void 0;
+const node_process_1 = __importDefault(require("process"));
+const node_assert_1 = __importDefault(require("assert"));
+const node_os_1 = require("os");
+const format_js_1 = require("./format.js");
+const hr_js_1 = require("./hr.js");
+const findFile = (error) => {
+    var _a;
+    const stackLines = ((_a = error.stack) === null || _a === void 0 ? void 0 : _a.split(node_os_1.EOL)) || [];
+    let file = '';
+    const basePath = 'poku/lib/';
+    for (const line of stackLines) {
+        if (!line.includes(basePath)) {
+            const match = line.match(/at\s(\/.+|file:\/\/\/.+)/i);
+            if (match && match[1]) {
+                file = match[1];
+                break;
+            }
+        }
+    }
+    return file;
+};
+const parseAssertion = (cb, options) => {
+    try {
+        cb();
+    }
+    catch (error) {
+        if (error instanceof node_assert_1.default.AssertionError) {
+            const { code, actual, expected, operator } = error;
+            const file = findFile(error);
+            (0, hr_js_1.hr)();
+            if (typeof options.message === 'string')
+                console.log(format_js_1.format.bold(options.message), node_os_1.EOL);
+            else if (options.message instanceof Error)
+                console.log(format_js_1.format.bold(options.message.message), node_os_1.EOL);
+            else if (typeof options.defaultMessage === 'string')
+                console.log(options.defaultMessage, node_os_1.EOL);
+            console.log(format_js_1.format.dim('Code:    '), format_js_1.format.bold(format_js_1.format.fail(code)));
+            file && console.log(format_js_1.format.dim('File:    '), file);
+            console.log(format_js_1.format.dim('Operator:'), operator);
+            (0, hr_js_1.hr)();
+            if (!(options === null || options === void 0 ? void 0 : options.hideDiff)) {
+                console.log(format_js_1.format.dim(`${(options === null || options === void 0 ? void 0 : options.actual) || 'Actual'}:`));
+                console.log(format_js_1.format.bold(typeof actual === 'function' || actual instanceof RegExp
+                    ? String(actual)
+                    : format_js_1.format.fail(JSON.stringify(actual))));
+                console.log(`${node_os_1.EOL}${format_js_1.format.dim(`${(options === null || options === void 0 ? void 0 : options.expected) || 'Expected'}:`)}`);
+                console.log(format_js_1.format.bold(typeof expected === 'function' || expected instanceof RegExp
+                    ? String(expected)
+                    : format_js_1.format.success(JSON.stringify(expected))));
+                (0, hr_js_1.hr)();
+            }
+            if (options.throw) {
+                console.log(error);
+                (0, hr_js_1.hr)();
+            }
+            node_process_1.default.exit(1);
+        }
+        // Non-assertion errors
+        throw error;
+    }
+};
+exports.parseAssertion = parseAssertion;

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 export { poku } from './modules/poku.js';
 export { exit } from './modules/exit.js';
+export { assert } from './modules/assert.js';
 export { publicListFiles as listFiles } from './modules/list-files.js';
 export type { Code } from './@types/code.ts';
 export type { Configs } from './@types/poku.ts';

package/lib/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listFiles = exports.exit = exports.poku = void 0;
+exports.listFiles = exports.assert = exports.exit = exports.poku = void 0;
 var poku_js_1 = require("./modules/poku.js");
 Object.defineProperty(exports, "poku", { enumerable: true, get: function () { return poku_js_1.poku; } });
 var exit_js_1 = require("./modules/exit.js");
 Object.defineProperty(exports, "exit", { enumerable: true, get: function () { return exit_js_1.exit; } });
+var assert_js_1 = require("./modules/assert.js");
+Object.defineProperty(exports, "assert", { enumerable: true, get: function () { return assert_js_1.assert; } });
 var list_files_js_1 = require("./modules/list-files.js");
 Object.defineProperty(exports, "listFiles", { enumerable: true, get: function () { return list_files_js_1.publicListFiles; } });

package/lib/modules/assert.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import * as nodeAssert from 'node:assert';
+import { ParseAssertionOptions } from '../helpers/parseAsssetion.js';
+declare function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
+declare function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, error: nodeAssert.AssertPredicate, message?: string | Error): Promise<void>;
+declare function doesNotThrow(block: () => unknown, message?: string | ParseAssertionOptions['message']): void;
+declare function doesNotThrow(block: () => unknown, error: nodeAssert.AssertPredicate, message?: ParseAssertionOptions['message']): void;
+declare function throws(block: () => unknown, message?: ParseAssertionOptions['message']): void;
+declare function throws(block: () => unknown, error: nodeAssert.AssertPredicate, message?: ParseAssertionOptions['message']): void;
+declare function rejects(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
+declare function rejects(block: (() => Promise<unknown>) | Promise<unknown>, error: nodeAssert.AssertPredicate, message?: string | Error): Promise<void>;
+export declare const assert: ((value: unknown, message?: ParseAssertionOptions['message']) => void) & {
+    ok: (value: unknown, message?: ParseAssertionOptions['message']) => void;
+    equal: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => void;
+    deepEqual: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => void;
+    strictEqual: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => void;
+    deepStrictEqual: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => void;
+    doesNotMatch: (value: string, regExp: RegExp, message?: ParseAssertionOptions['message']) => void;
+    doesNotReject: typeof doesNotReject;
+    throws: typeof throws;
+    doesNotThrow: typeof doesNotThrow;
+    notEqual: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => void;
+    notDeepEqual: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => void;
+    notStrictEqual: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => void;
+    notDeepStrictEqual: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => void;
+    match: (value: string, regExp: RegExp, message?: ParseAssertionOptions['message']) => void;
+    ifError: (value: unknown) => void;
+    fail: (message?: ParseAssertionOptions['message']) => void;
+    rejects: typeof rejects;
+};
+export {};

package/lib/modules/assert.js

@@ -0,0 +1,253 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+const nodeAssert = __importStar(require("assert"));
+const parseAsssetion_js_1 = require("../helpers/parseAsssetion.js");
+const format_js_1 = require("../helpers/format.js");
+const ok = (value, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.ok(value), { message });
+const equal = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.equal(actual, expected), { message });
+const deepEqual = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.deepEqual(actual, expected), { message });
+const strictEqual = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.strictEqual(actual, expected), { message });
+const deepStrictEqual = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.deepStrictEqual(actual, expected), {
+    message,
+});
+const doesNotMatch = (value, regExp, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.doesNotMatch(value, regExp), {
+    message,
+    actual: 'Value',
+    expected: 'RegExp',
+    defaultMessage: format_js_1.format.bold('Value should not match regExp'),
+});
+function doesNotReject(block, errorOrMessage, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof errorOrMessage === 'function' ||
+            errorOrMessage instanceof RegExp ||
+            typeof errorOrMessage === 'object') {
+            try {
+                return yield nodeAssert.doesNotReject(block, errorOrMessage);
+            }
+            catch (error) {
+                (0, parseAsssetion_js_1.parseAssertion)(() => {
+                    throw error;
+                }, {
+                    message,
+                    defaultMessage: format_js_1.format.bold('Got unwanted rejection'),
+                    hideDiff: true,
+                    throw: true,
+                });
+            }
+        }
+        else {
+            try {
+                return yield nodeAssert.doesNotReject(block);
+            }
+            catch (error_1) {
+                (0, parseAsssetion_js_1.parseAssertion)(() => {
+                    throw error_1;
+                }, {
+                    message: typeof errorOrMessage === 'string' ? errorOrMessage : undefined,
+                    defaultMessage: format_js_1.format.bold('Got unwanted rejection'),
+                    hideDiff: true,
+                    throw: true,
+                });
+            }
+        }
+    });
+}
+function doesNotThrow(block, errorOrMessage, message) {
+    if (typeof errorOrMessage === 'function' ||
+        errorOrMessage instanceof RegExp ||
+        typeof errorOrMessage === 'object') {
+        try {
+            nodeAssert.doesNotThrow(block, errorOrMessage, message);
+        }
+        catch (error) {
+            (0, parseAsssetion_js_1.parseAssertion)(() => {
+                throw error;
+            }, {
+                message: message,
+                defaultMessage: format_js_1.format.bold('Expected function not to throw'),
+                hideDiff: true,
+                throw: true,
+            });
+        }
+    }
+    else {
+        const msg = typeof errorOrMessage === 'string' ? errorOrMessage : undefined;
+        try {
+            nodeAssert.doesNotThrow(block, msg);
+        }
+        catch (error) {
+            (0, parseAsssetion_js_1.parseAssertion)(() => {
+                throw error;
+            }, {
+                message: msg,
+                defaultMessage: format_js_1.format.bold('Expected function not to throw'),
+                hideDiff: true,
+                throw: true,
+            });
+        }
+    }
+}
+function throws(block, errorOrMessage, message) {
+    if (typeof errorOrMessage === 'function' ||
+        errorOrMessage instanceof RegExp ||
+        typeof errorOrMessage === 'object') {
+        try {
+            nodeAssert.throws(block, errorOrMessage, message);
+        }
+        catch (error) {
+            (0, parseAsssetion_js_1.parseAssertion)(() => {
+                throw error;
+            }, {
+                message: message,
+                defaultMessage: format_js_1.format.bold('Expected function to throw'),
+                hideDiff: true,
+            });
+        }
+    }
+    else {
+        const msg = typeof errorOrMessage === 'string' ? errorOrMessage : undefined;
+        try {
+            nodeAssert.throws(block, message);
+        }
+        catch (error) {
+            (0, parseAsssetion_js_1.parseAssertion)(() => {
+                throw error;
+            }, {
+                message: msg,
+                defaultMessage: format_js_1.format.bold('Expected function to throw'),
+                hideDiff: true,
+            });
+        }
+    }
+}
+const notEqual = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notEqual(actual, expected), {
+    message,
+});
+const notDeepEqual = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notDeepEqual(actual, expected), { message });
+const notStrictEqual = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notStrictEqual(actual, expected), {
+    message,
+});
+const notDeepStrictEqual = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notDeepStrictEqual(actual, expected), {
+    message,
+});
+const match = (value, regExp, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.match(value, regExp), {
+    message,
+    actual: 'Value',
+    expected: 'RegExp',
+    defaultMessage: format_js_1.format.bold('Value should match regExp'),
+});
+const ifError = (value) => {
+    try {
+        nodeAssert.ifError(value);
+    }
+    catch (error) {
+        (0, parseAsssetion_js_1.parseAssertion)(() => {
+            throw error;
+        }, {
+            defaultMessage: format_js_1.format.bold('Expected no error, but received an error'),
+            hideDiff: true,
+            throw: true,
+        });
+    }
+};
+const fail = (message) => {
+    try {
+        nodeAssert.fail(message);
+    }
+    catch (error) {
+        (0, parseAsssetion_js_1.parseAssertion)(() => {
+            throw error;
+        }, {
+            message,
+            defaultMessage: format_js_1.format.bold('Test failed intentionally'),
+            hideDiff: true,
+        });
+    }
+};
+function rejects(block, errorOrMessage, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof errorOrMessage === 'function' ||
+            errorOrMessage instanceof RegExp ||
+            typeof errorOrMessage === 'object') {
+            try {
+                return yield nodeAssert.rejects(block, errorOrMessage);
+            }
+            catch (error) {
+                (0, parseAsssetion_js_1.parseAssertion)(() => {
+                    throw error;
+                }, {
+                    message,
+                    defaultMessage: format_js_1.format.bold('Expected promise to be rejected with specified error'),
+                    hideDiff: true,
+                });
+            }
+        }
+        else {
+            const msg = typeof errorOrMessage === 'string' ? errorOrMessage : undefined;
+            try {
+                return yield nodeAssert.rejects(block);
+            }
+            catch (error_1) {
+                (0, parseAsssetion_js_1.parseAssertion)(() => {
+                    throw error_1;
+                }, {
+                    message: msg,
+                    defaultMessage: format_js_1.format.bold('Expected promise to be rejected'),
+                    hideDiff: true,
+                });
+            }
+        }
+    });
+}
+exports.assert = Object.assign((value, message) => ok(value, message), {
+    ok,
+    equal,
+    deepEqual,
+    strictEqual,
+    deepStrictEqual,
+    doesNotMatch,
+    doesNotReject,
+    throws,
+    doesNotThrow,
+    notEqual,
+    notDeepEqual,
+    notStrictEqual,
+    notDeepStrictEqual,
+    match,
+    ifError,
+    fail,
+    rejects,
+});

package/lib/modules/list-files.js

@@ -8,7 +8,7 @@ exports.publicListFiles = exports.listFiles = exports.escapeRegExp = void 0;
 const node_process_1 = __importDefault(require("process"));
 const node_fs_1 = __importDefault(require("fs"));
 const node_path_1 = __importDefault(require("path"));
-const escapeRegExp = (string) => string.replace(/[.*+?^${}()[\]\\]/g, '\\$&');
+const escapeRegExp = (string) => string.replace(/[.*{}[\]\\]/g, '\\$&');
 exports.escapeRegExp = escapeRegExp;
 const envFilter = ((_a = node_process_1.default.env.FILTER) === null || _a === void 0 ? void 0 : _a.trim())
     ? new RegExp((0, exports.escapeRegExp)(node_process_1.default.env.FILTER), 'i')

package/lib/services/run-test-file.js

@@ -16,7 +16,7 @@ const runTestFile = (filePath, configs) => new Promise((resolve) => {
     const showLogs = !(0, logs_js_1.isQuiet)(configs);
     const showSuccess = (0, logs_js_1.showSuccesses)(configs);
     const showFailure = (0, logs_js_1.showFailures)(configs);
-    const log = () => console.log(`${indentation_js_1.indentation.stdio}${output === null || output === void 0 ? void 0 : output.trim()}`);
+    const log = () => console.log(output === null || output === void 0 ? void 0 : output.trim());
     const fileRelative = node_path_1.default.relative(node_process_1.default.cwd(), filePath);
     showLogs &&
         console.log(`${indentation_js_1.indentation.test}${format_js_1.format.info('→')} ${fileRelative}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poku",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "🐷 Poku is a flexible and easy-to-use Test Runner for Node.js, Bun and Deno that allows you to run parallel and sequential tests, plus high isolation level per test file",
   "main": "./lib/index.js",
   "scripts": {
@@ -12,7 +12,7 @@
     "update": "npx npu;",
     "prebuild": "rm -rf ./lib ./ci",
     "build": "npx tsc; npx tsc -p tsconfig.test.json",
-    "postbuild": "npx tsx ./tools/compatibility/node.ts; npm audit",
+    "postbuild": "npx tsx ./tools/compatibility/node.ts; chmod +x lib/bin/index.js; npm audit",
     "eslint:checker": "npx eslint . --ext .js,.ts",
     "eslint:fix": "npx eslint . --fix --config ./.eslintrc.json",
     "prettier:checker": "npx prettier --check .",
@@ -27,9 +27,12 @@
     "poku": "./lib/bin/index.js"
   },
   "keywords": [
+    "🐷",
     "test",
-    "testing",
     "runner",
+    "assert",
+    "assertion",
+    "testing",
     "run",
     "isolate",
     "isolation",
@@ -41,13 +44,29 @@
     "unit",
     "integration",
     "typescript",
-    "filter",
     "queue",
     "queuing",
     "nodejs",
     "node",
     "bun",
-    "deno"
+    "deno",
+    "cli",
+    "cli-app",
+    "expect",
+    "mocha",
+    "jest",
+    "ava",
+    "tap",
+    "tape",
+    "karma",
+    "filter",
+    "exclude",
+    "list",
+    "files",
+    "list-files",
+    "tsx",
+    "fast",
+    "easy"
   ],
   "author": "https://github.com/wellwelwel",
   "bugs": {