poku 2.4.1 → 2.4.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (13) hide show
  1. package/README.md +2 -2
  2. package/lib/builders/assert.d.ts +34 -0
  3. package/lib/builders/assert.js +183 -0
  4. package/lib/configs/poku.js +1 -1
  5. package/lib/modules/essentials/assert.js +1 -1
  6. package/lib/modules/essentials/poku.js +1 -0
  7. package/lib/modules/essentials/strict.js +1 -1
  8. package/lib/modules/helpers/exit.d.ts +1 -1
  9. package/lib/modules/helpers/exit.js +12 -7
  10. package/lib/services/assert.d.ts +1 -34
  11. package/lib/services/assert.js +44 -195
  12. package/lib/services/write.js +1 -1
  13. package/package.json +3 -3
package/README.md CHANGED
@@ -6,7 +6,7 @@
6
6
  Enjoying **Poku**? Give him a star to show your support 🌟
7
7
 
8
8
  [![NPM Downloads](https://img.shields.io/npm/v/poku.svg?label=&color=70a1ff&logo=npm&logoColor=white)](https://www.npmjs.com/package/poku)
9
- [![NPM Downloads](https://img.shields.io/npm/dt/poku.svg?label=&logo=npm&logoColor=white&color=45aaf2)](https://www.npmjs.com/package/poku)
9
+ [![NPM Downloads](https://img.shields.io/npm/dm/poku.svg?label=&logo=npm&logoColor=white&color=45aaf2)](https://www.npmjs.com/package/poku)
10
10
  [![Coverage](https://img.shields.io/codecov/c/github/wellwelwel/poku?label=&logo=codecov&logoColor=white&color=98cc00)](https://github.com/wellwelwel/poku/tree/main/.nycrc)<br />
11
11
  [![GitHub Workflow Status (Linux)](https://img.shields.io/github/actions/workflow/status/wellwelwel/poku/ci_coverage-linux.yml?event=push&label=&branch=main&logo=ubuntu&logoColor=8897a9&color=dfe4ea)](https://github.com/wellwelwel/poku/actions/workflows/ci_coverage-linux.yml?query=branch%3Amain)
12
12
  [![GitHub Workflow Status (OSX)](https://img.shields.io/github/actions/workflow/status/wellwelwel/poku/ci_coverage-osx.yml?event=push&label=&branch=main&logo=apple&logoColor=8897a9&color=dfe4ea)](https://github.com/wellwelwel/poku/actions/workflows/ci_coverage-osx.yml?query=branch%3Amain)
@@ -270,7 +270,7 @@ To see the detailed documentation, please visit the [**Documentation**](https://
270
270
  - [~**130x** lighter than **Jest**](https://pkg-size.dev/jest)
271
271
  - [~**30x** lighter than **Mocha** + **Chai**](https://pkg-size.dev/mocha%20chai)
272
272
 
273
- > **Poku** size is highly significant in development to ensure cost-saving **CI** that require servers that charge for storage and usage.
273
+ > **Poku** size ensures _cost-saving_ **CI** for services that charge for storage and usage.
274
274
 
275
275
  ---
276
276
 
package/lib/builders/assert.d.ts ADDED
@@ -0,0 +1,34 @@
1
+ import type { ProcessAssertionOptions } from '../@types/assert.js';
2
+ import type assert from 'node:assert';
3
+ import type { AssertPredicate } from 'node:assert';
4
+ export declare const createAssert: (nodeAssert: typeof assert) => ((value: unknown, message?: ProcessAssertionOptions["message"]) => void) & {
5
+ ok: (value: unknown, message?: ProcessAssertionOptions["message"]) => void;
6
+ equal: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
7
+ deepEqual: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
8
+ strictEqual: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
9
+ deepStrictEqual: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
10
+ doesNotMatch: (value: string, regExp: RegExp, message?: ProcessAssertionOptions["message"]) => void;
11
+ doesNotReject: {
12
+ (block: (() => Promise<unknown>) | Promise<unknown>, message?: ProcessAssertionOptions["message"]): Promise<void>;
13
+ (block: (() => Promise<unknown>) | Promise<unknown>, error: AssertPredicate, message?: ProcessAssertionOptions["message"]): Promise<void>;
14
+ };
15
+ throws: {
16
+ (block: () => unknown, message?: ProcessAssertionOptions["message"]): void;
17
+ (block: () => unknown, error: AssertPredicate, message?: ProcessAssertionOptions["message"]): void;
18
+ };
19
+ doesNotThrow: {
20
+ (block: () => unknown, message?: string | ProcessAssertionOptions["message"]): void;
21
+ (block: () => unknown, error: AssertPredicate, message?: ProcessAssertionOptions["message"]): void;
22
+ };
23
+ notEqual: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
24
+ notDeepEqual: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
25
+ notStrictEqual: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
26
+ notDeepStrictEqual: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
27
+ match: (value: string, regExp: RegExp, message?: ProcessAssertionOptions["message"]) => void;
28
+ ifError: (value: unknown, message?: ProcessAssertionOptions["message"]) => void;
29
+ fail: (message?: ProcessAssertionOptions["message"]) => never;
30
+ rejects: {
31
+ (block: (() => Promise<unknown>) | Promise<unknown>, message?: ProcessAssertionOptions["message"]): Promise<void>;
32
+ (block: (() => Promise<unknown>) | Promise<unknown>, error: AssertPredicate, message?: ProcessAssertionOptions["message"]): Promise<void>;
33
+ };
34
+ };
package/lib/builders/assert.js ADDED
@@ -0,0 +1,183 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.createAssert = void 0;
4
+ const get_runtime_js_1 = require("../parsers/get-runtime.js");
5
+ const assert_js_1 = require("../services/assert.js");
6
+ const createAssert = (nodeAssert) => {
7
+ const ok = (value, message) => {
8
+ (0, assert_js_1.processAssert)(() => {
9
+ nodeAssert.ok(value);
10
+ }, { message });
11
+ };
12
+ const equal = (actual, expected, message) => {
13
+ (0, assert_js_1.processAssert)(() => {
14
+ nodeAssert.equal(actual, expected);
15
+ }, { message });
16
+ };
17
+ const deepEqual = (actual, expected, message) => {
18
+ (0, assert_js_1.processAssert)(() => nodeAssert.deepEqual(actual, expected), { message });
19
+ };
20
+ const strictEqual = (actual, expected, message) => {
21
+ (0, assert_js_1.processAssert)(() => nodeAssert.strictEqual(actual, expected), { message });
22
+ };
23
+ const deepStrictEqual = (actual, expected, message) => {
24
+ (0, assert_js_1.processAssert)(() => nodeAssert.deepStrictEqual(actual, expected), {
25
+ message,
26
+ });
27
+ };
28
+ const notEqual = (actual, expected, message) => {
29
+ (0, assert_js_1.processAssert)(() => nodeAssert.notEqual(actual, expected), {
30
+ message,
31
+ });
32
+ };
33
+ const notDeepEqual = (actual, expected, message) => {
34
+ (0, assert_js_1.processAssert)(() => nodeAssert.notDeepEqual(actual, expected), { message });
35
+ };
36
+ const notStrictEqual = (actual, expected, message) => {
37
+ (0, assert_js_1.processAssert)(() => nodeAssert.notStrictEqual(actual, expected), {
38
+ message,
39
+ });
40
+ };
41
+ const notDeepStrictEqual = (actual, expected, message) => {
42
+ (0, assert_js_1.processAssert)(() => nodeAssert.notDeepStrictEqual(actual, expected), {
43
+ message,
44
+ });
45
+ };
46
+ const ifError = (value, message) => {
47
+ (0, assert_js_1.processAssert)(() => {
48
+ nodeAssert.ifError(value);
49
+ }, {
50
+ message,
51
+ defaultMessage: 'Expected no error, but received an error',
52
+ hideDiff: true,
53
+ throw: true,
54
+ });
55
+ };
56
+ const fail = (message) => {
57
+ (0, assert_js_1.processAssert)(() => {
58
+ nodeAssert.fail(message);
59
+ }, {
60
+ message,
61
+ defaultMessage: 'Test failed intentionally',
62
+ hideDiff: true,
63
+ });
64
+ process.exit(1);
65
+ };
66
+ function doesNotThrow(block, errorOrMessage, message) {
67
+ (0, assert_js_1.processAssert)(() => {
68
+ if (typeof errorOrMessage === 'function' ||
69
+ errorOrMessage instanceof RegExp ||
70
+ typeof errorOrMessage === 'object') {
71
+ nodeAssert.doesNotThrow(block, errorOrMessage, message);
72
+ }
73
+ else {
74
+ const msg = typeof errorOrMessage === 'string' ? errorOrMessage : message;
75
+ nodeAssert.doesNotThrow(block, msg);
76
+ }
77
+ }, {
78
+ message: typeof errorOrMessage === 'string' ? errorOrMessage : message,
79
+ defaultMessage: 'Expected function not to throw',
80
+ hideDiff: true,
81
+ throw: true,
82
+ });
83
+ }
84
+ function throws(block, errorOrMessage, message) {
85
+ if (typeof errorOrMessage === 'function' ||
86
+ errorOrMessage instanceof RegExp ||
87
+ typeof errorOrMessage === 'object') {
88
+ (0, assert_js_1.processAssert)(() => nodeAssert.throws(block, errorOrMessage), {
89
+ message,
90
+ defaultMessage: 'Expected function to throw',
91
+ hideDiff: true,
92
+ });
93
+ }
94
+ else {
95
+ const msg = typeof errorOrMessage !== 'undefined' ? errorOrMessage : message;
96
+ (0, assert_js_1.processAssert)(() => nodeAssert.throws(block, message), {
97
+ message: msg,
98
+ defaultMessage: 'Expected function to throw',
99
+ hideDiff: true,
100
+ });
101
+ }
102
+ }
103
+ async function rejects(block, errorOrMessage, message) {
104
+ await (0, assert_js_1.processAsyncAssert)(async () => {
105
+ if (typeof errorOrMessage === 'function' ||
106
+ errorOrMessage instanceof RegExp ||
107
+ typeof errorOrMessage === 'object') {
108
+ await nodeAssert.rejects(block, errorOrMessage, message);
109
+ }
110
+ else {
111
+ const msg = typeof errorOrMessage === 'string' ? errorOrMessage : message;
112
+ await nodeAssert.rejects(block, msg);
113
+ }
114
+ }, {
115
+ message: typeof errorOrMessage === 'string' ? errorOrMessage : message,
116
+ defaultMessage: 'Expected promise to be rejected with specified error',
117
+ hideDiff: true,
118
+ throw: true,
119
+ });
120
+ }
121
+ async function doesNotReject(block, errorOrMessage, message) {
122
+ await (0, assert_js_1.processAsyncAssert)(async () => {
123
+ if (typeof errorOrMessage === 'function' ||
124
+ errorOrMessage instanceof RegExp ||
125
+ typeof errorOrMessage === 'object') {
126
+ await nodeAssert.doesNotReject(block, errorOrMessage, message);
127
+ }
128
+ else {
129
+ await nodeAssert.doesNotReject(block, message);
130
+ }
131
+ }, {
132
+ message: typeof errorOrMessage === 'string' ? errorOrMessage : message,
133
+ defaultMessage: 'Got unwanted rejection',
134
+ hideDiff: true,
135
+ throw: true,
136
+ });
137
+ }
138
+ const match = (value, regExp, message) => {
139
+
140
+ if (typeof get_runtime_js_1.nodeVersion === 'number' && get_runtime_js_1.nodeVersion < 12) {
141
+ throw new Error('match is available from Node.js 12 or higher');
142
+ }
143
+ (0, assert_js_1.processAssert)(() => nodeAssert === null || nodeAssert === void 0 ? void 0 : nodeAssert.match(value, regExp), {
144
+ message,
145
+ actual: 'Value',
146
+ expected: 'RegExp',
147
+ defaultMessage: 'Value should match regExp',
148
+ });
149
+ };
150
+ const doesNotMatch = (value, regExp, message) => {
151
+
152
+ if (typeof get_runtime_js_1.nodeVersion === 'number' && get_runtime_js_1.nodeVersion < 12) {
153
+ throw new Error('doesNotMatch is available from Node.js 12 or higher');
154
+ }
155
+ (0, assert_js_1.processAssert)(() => nodeAssert.doesNotMatch(value, regExp), {
156
+ message,
157
+ actual: 'Value',
158
+ expected: 'RegExp',
159
+ defaultMessage: 'Value should not match regExp',
160
+ });
161
+ };
162
+ const assert = Object.assign((value, message) => ok(value, message), {
163
+ ok,
164
+ equal,
165
+ deepEqual,
166
+ strictEqual,
167
+ deepStrictEqual,
168
+ doesNotMatch,
169
+ doesNotReject,
170
+ throws,
171
+ doesNotThrow,
172
+ notEqual,
173
+ notDeepEqual,
174
+ notStrictEqual,
175
+ notDeepStrictEqual,
176
+ match,
177
+ ifError,
178
+ fail,
179
+ rejects,
180
+ });
181
+ return assert;
182
+ };
183
+ exports.createAssert = createAssert;
package/lib/configs/poku.js CHANGED
@@ -7,4 +7,4 @@ exports.results = {
7
7
  skip: 0,
8
8
  todo: 0,
9
9
  };
10
- exports.VERSION = '2.4.1';
10
+ exports.VERSION = '2.4.3';
package/lib/modules/essentials/assert.js CHANGED
@@ -5,5 +5,5 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
5
5
  Object.defineProperty(exports, "__esModule", { value: true });
6
6
  exports.assert = void 0;
7
7
  const node_assert_1 = __importDefault(require("assert"));
8
- const assert_js_1 = require("../../services/assert.js");
8
+ const assert_js_1 = require("../../builders/assert.js");
9
9
  exports.assert = (0, assert_js_1.createAssert)(node_assert_1.default);
package/lib/modules/essentials/poku.js CHANGED
@@ -43,6 +43,7 @@ async function poku(targetPaths, configs) {
43
43
  files_js_1.finalResults.time = total;
44
44
  showLogs && (0, format_js_1.showTestResults)();
45
45
  (0, exit_js_1.exit)(code, configs === null || configs === void 0 ? void 0 : configs.quiet);
46
+ return;
46
47
  }
47
48
 
48
49
  if (showLogs) {
package/lib/modules/essentials/strict.js CHANGED
@@ -5,5 +5,5 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
5
5
  Object.defineProperty(exports, "__esModule", { value: true });
6
6
  exports.strict = void 0;
7
7
  const strict_1 = __importDefault(require("assert/strict"));
8
- const assert_js_1 = require("../../services/assert.js");
8
+ const assert_js_1 = require("../../builders/assert.js");
9
9
  exports.strict = (0, assert_js_1.createAssert)(strict_1.default);
package/lib/modules/helpers/exit.d.ts CHANGED
@@ -1,2 +1,2 @@
1
1
  import type { Code } from '../../@types/code.js';
2
- export declare const exit: (code: Code, quiet?: boolean) => never;
2
+ export declare const exit: (code: Code, quiet?: boolean) => void;
package/lib/modules/helpers/exit.js CHANGED
@@ -10,6 +10,7 @@ const format_js_1 = require("../../services/format.js");
10
10
  const write_js_1 = require("../../services/write.js");
11
11
  const files_js_1 = require("../../configs/files.js");
12
12
  const time_js_1 = require("../../parsers/time.js");
13
+ const node_assert_1 = require("assert");
13
14
  const exit = (code, quiet) => {
14
15
  const isPoku = poku_js_1.results.success > 0 || poku_js_1.results.fail > 0;
15
16
  const success = ` PASS › ${poku_js_1.results.success - poku_js_1.results.skip || 0} `;
@@ -49,16 +50,20 @@ const exit = (code, quiet) => {
49
50
  }
50
51
  write_js_1.Write.log(`${(0, format_js_1.format)('Exited with code').dim()} ${(0, format_js_1.format)(String(code)).bold()[code === 0 ? 'success' : 'fail']()}\n`);
51
52
  });
52
- node_process_1.default.exit(code === 0 ? 0 : 1);
53
+ node_process_1.default.exitCode = code === 0 ? 0 : 1;
53
54
  };
54
55
  exports.exit = exit;
55
56
 
56
- node_process_1.default.on('unhandledRejection', (reason) => {
57
- console.error('unhandledRejection', reason);
58
- node_process_1.default.exit(1);
57
+ node_process_1.default.on('unhandledRejection', (err) => {
58
+ if (!(err instanceof node_assert_1.AssertionError)) {
59
+ console.error('unhandledRejection', err);
60
+ }
61
+ node_process_1.default.exitCode = 1;
59
62
  });
60
-
61
63
  node_process_1.default.on('uncaughtException', (err) => {
62
- console.error('uncaughtException', err);
63
- node_process_1.default.exit(1);
64
+ if (!(err instanceof node_assert_1.AssertionError)) {
65
+ console.error('uncaughtException', err);
66
+ }
67
+ node_process_1.default.exitCode = 1;
64
68
  });
69
+
package/lib/services/assert.d.ts CHANGED
@@ -1,35 +1,2 @@
1
1
  import type { ProcessAssertionOptions } from '../@types/assert.js';
2
- import type assert from 'node:assert';
3
- import type { AssertPredicate } from 'node:assert';
4
- export declare const processAssert: (cb: () => void | Promise<void>, options: ProcessAssertionOptions) => Promise<void>;
5
- export declare const createAssert: (nodeAssert: typeof assert) => ((value: unknown, message?: ProcessAssertionOptions["message"]) => void) & {
6
- ok: (value: unknown, message?: ProcessAssertionOptions["message"]) => void;
7
- equal: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
8
- deepEqual: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
9
- strictEqual: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
10
- deepStrictEqual: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
11
- doesNotMatch: (value: string, regExp: RegExp, message?: ProcessAssertionOptions["message"]) => void;
12
- doesNotReject: {
13
- (block: (() => Promise<unknown>) | Promise<unknown>, message?: ProcessAssertionOptions["message"]): Promise<void>;
14
- (block: (() => Promise<unknown>) | Promise<unknown>, error: AssertPredicate, message?: ProcessAssertionOptions["message"]): Promise<void>;
15
- };
16
- throws: {
17
- (block: () => unknown, message?: ProcessAssertionOptions["message"]): void;
18
- (block: () => unknown, error: AssertPredicate, message?: ProcessAssertionOptions["message"]): void;
19
- };
20
- doesNotThrow: {
21
- (block: () => unknown, message?: string | ProcessAssertionOptions["message"]): void;
22
- (block: () => unknown, error: AssertPredicate, message?: ProcessAssertionOptions["message"]): void;
23
- };
24
- notEqual: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
25
- notDeepEqual: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
26
- notStrictEqual: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
27
- notDeepStrictEqual: (actual: unknown, expected: unknown, message?: ProcessAssertionOptions["message"]) => void;
28
- match: (value: string, regExp: RegExp, message?: ProcessAssertionOptions["message"]) => void;
29
- ifError: (value: unknown, message?: ProcessAssertionOptions["message"]) => void;
30
- fail: (message?: ProcessAssertionOptions["message"]) => never;
31
- rejects: {
32
- (block: (() => Promise<unknown>) | Promise<unknown>, message?: ProcessAssertionOptions["message"]): Promise<void>;
33
- (block: (() => Promise<unknown>) | Promise<unknown>, error: AssertPredicate, message?: ProcessAssertionOptions["message"]): Promise<void>;
34
- };
35
- };
2
+ export declare const processAssert: (cb: () => void, options: ProcessAssertionOptions) => void, processAsyncAssert: (cb: () => Promise<void>, options: ProcessAssertionOptions) => Promise<void>;
package/lib/services/assert.js CHANGED
@@ -2,46 +2,51 @@
2
2
  var __importDefault = (this && this.__importDefault) || function (mod) {
3
3
  return (mod && mod.__esModule) ? mod : { "default": mod };
4
4
  };
5
+ var _a;
5
6
  Object.defineProperty(exports, "__esModule", { value: true });
6
- exports.createAssert = exports.processAssert = void 0;
7
+ exports.processAsyncAssert = exports.processAssert = void 0;
7
8
  const node_assert_1 = require("assert");
8
- const node_process_1 = require("process");
9
+ const node_process_1 = __importDefault(require("process"));
9
10
  const node_path_1 = __importDefault(require("path"));
10
11
  const find_file_from_stack_js_1 = require("../parsers/find-file-from-stack.js");
11
12
  const assert_js_1 = require("../parsers/assert.js");
12
- const get_runtime_js_1 = require("../parsers/get-runtime.js");
13
13
  const indentation_js_1 = require("../configs/indentation.js");
14
14
  const format_js_1 = require("./format.js");
15
15
  const write_js_1 = require("./write.js");
16
- const cwd = (0, node_process_1.cwd)();
16
+ const cwd = node_process_1.default.cwd();
17
17
  const regexFile = /file:(\/\/)?/;
18
- const processAssert = async (cb, options) => {
19
- const isPoku = typeof (node_process_1.env === null || node_process_1.env === void 0 ? void 0 : node_process_1.env.FILE) === 'string' && (node_process_1.env === null || node_process_1.env === void 0 ? void 0 : node_process_1.env.FILE.length) > 0;
20
- const FILE = node_process_1.env.FILE;
18
+ const assertProcessor = () => {
19
+ var _a, _b;
20
+ const isPoku = typeof ((_a = node_process_1.default.env) === null || _a === void 0 ? void 0 : _a.FILE) === 'string' && ((_b = node_process_1.default.env) === null || _b === void 0 ? void 0 : _b.FILE.length) > 0;
21
+ const FILE = node_process_1.default.env.FILE;
21
22
  let preIdentation = '';
22
- if (indentation_js_1.indentation.hasDescribe) {
23
- preIdentation += ' ';
24
- }
25
- if (indentation_js_1.indentation.hasItOrTest) {
26
- preIdentation += ' ';
27
- }
28
- try {
29
- const cbResult = cb();
30
- if (cbResult instanceof Promise) {
31
- await cbResult;
32
- }
23
+ const handleSuccess = (options) => {
33
24
  if (typeof options.message === 'string') {
25
+ if (indentation_js_1.indentation.hasDescribe) {
26
+ preIdentation += ' ';
27
+ }
28
+ if (indentation_js_1.indentation.hasItOrTest) {
29
+ preIdentation += ' ';
30
+ }
34
31
  const message = isPoku && !indentation_js_1.indentation.hasDescribe && !indentation_js_1.indentation.hasItOrTest
35
32
  ? `${preIdentation}${(0, format_js_1.format)(`${(0, format_js_1.format)(`✔ ${options.message}`).bold()} ${(0, format_js_1.format)(`› ${FILE}`).success().dim()}`).success()}`
36
33
  : `${preIdentation}${(0, format_js_1.format)(`✔ ${options.message}`).success().bold()}`;
37
34
  write_js_1.Write.log(message);
38
35
  }
39
- }
40
- catch (error) {
36
+ preIdentation = '';
37
+ };
38
+ const handleError = (error, options) => {
39
+ node_process_1.default.exitCode = 1;
41
40
  if (error instanceof node_assert_1.AssertionError) {
42
41
  const { code, actual, expected, operator } = error;
43
42
  const absolutePath = (0, find_file_from_stack_js_1.findFile)(error).replace(regexFile, '');
44
43
  const file = node_path_1.default.relative(node_path_1.default.resolve(cwd), absolutePath);
44
+ if (indentation_js_1.indentation.hasDescribe) {
45
+ preIdentation += ' ';
46
+ }
47
+ if (indentation_js_1.indentation.hasItOrTest) {
48
+ preIdentation += ' ';
49
+ }
45
50
  let message = '';
46
51
  if (typeof options.message === 'string') {
47
52
  message = options.message;
@@ -73,193 +78,37 @@ const processAssert = async (cb, options) => {
73
78
  for (const line of splitExpected) {
74
79
  write_js_1.Write.log(`${preIdentation} ${(0, format_js_1.format)(line).success().bold()}`);
75
80
  }
81
+ preIdentation = '';
76
82
  }
77
83
  if (options.throw) {
78
84
  console.error(error);
79
85
  write_js_1.Write.hr();
80
86
  }
81
- (0, node_process_1.exit)(1);
87
+ if (isPoku) {
88
+ throw error;
89
+ }
82
90
  }
83
91
 
84
92
  throw error;
85
- }
86
- };
87
- exports.processAssert = processAssert;
88
- const createAssert = (nodeAssert) => {
89
- const ok = (value, message) => {
90
- (0, exports.processAssert)(() => {
91
- nodeAssert.ok(value);
92
- }, { message });
93
- };
94
- const equal = (actual, expected, message) => {
95
- (0, exports.processAssert)(() => {
96
- nodeAssert.equal(actual, expected);
97
- }, { message });
98
- };
99
- const deepEqual = (actual, expected, message) => {
100
- (0, exports.processAssert)(() => nodeAssert.deepEqual(actual, expected), { message });
101
- };
102
- const strictEqual = (actual, expected, message) => {
103
- (0, exports.processAssert)(() => nodeAssert.strictEqual(actual, expected), { message });
104
- };
105
- const deepStrictEqual = (actual, expected, message) => {
106
- (0, exports.processAssert)(() => nodeAssert.deepStrictEqual(actual, expected), {
107
- message,
108
- });
109
- };
110
- const notEqual = (actual, expected, message) => {
111
- (0, exports.processAssert)(() => nodeAssert.notEqual(actual, expected), {
112
- message,
113
- });
114
- };
115
- const notDeepEqual = (actual, expected, message) => {
116
- (0, exports.processAssert)(() => nodeAssert.notDeepEqual(actual, expected), { message });
117
93
  };
118
- const notStrictEqual = (actual, expected, message) => {
119
- (0, exports.processAssert)(() => nodeAssert.notStrictEqual(actual, expected), {
120
- message,
121
- });
122
- };
123
- const notDeepStrictEqual = (actual, expected, message) => {
124
- (0, exports.processAssert)(() => nodeAssert.notDeepStrictEqual(actual, expected), {
125
- message,
126
- });
127
- };
128
- const ifError = (value, message) => {
129
- (0, exports.processAssert)(() => {
130
- nodeAssert.ifError(value);
131
- }, {
132
- message,
133
- defaultMessage: 'Expected no error, but received an error',
134
- hideDiff: true,
135
- throw: true,
136
- });
137
- };
138
- const fail = (message) => {
139
- (0, exports.processAssert)(() => {
140
- nodeAssert.fail(message);
141
- }, {
142
- message,
143
- defaultMessage: 'Test failed intentionally',
144
- hideDiff: true,
145
- });
146
- process.exit(1);
147
- };
148
- function doesNotThrow(block, errorOrMessage, message) {
149
- (0, exports.processAssert)(() => {
150
- if (typeof errorOrMessage === 'function' ||
151
- errorOrMessage instanceof RegExp ||
152
- typeof errorOrMessage === 'object') {
153
- nodeAssert.doesNotThrow(block, errorOrMessage, message);
154
- }
155
- else {
156
- const msg = typeof errorOrMessage === 'string' ? errorOrMessage : message;
157
- nodeAssert.doesNotThrow(block, msg);
158
- }
159
- }, {
160
- message: typeof errorOrMessage === 'string' ? errorOrMessage : message,
161
- defaultMessage: 'Expected function not to throw',
162
- hideDiff: true,
163
- throw: true,
164
- });
165
- }
166
- function throws(block, errorOrMessage, message) {
167
- if (typeof errorOrMessage === 'function' ||
168
- errorOrMessage instanceof RegExp ||
169
- typeof errorOrMessage === 'object') {
170
- (0, exports.processAssert)(() => nodeAssert.throws(block, errorOrMessage), {
171
- message,
172
- defaultMessage: 'Expected function to throw',
173
- hideDiff: true,
174
- });
175
- }
176
- else {
177
- const msg = typeof errorOrMessage !== 'undefined' ? errorOrMessage : message;
178
- (0, exports.processAssert)(() => nodeAssert.throws(block, message), {
179
- message: msg,
180
- defaultMessage: 'Expected function to throw',
181
- hideDiff: true,
182
- });
94
+ const processAssert = (cb, options) => {
95
+ try {
96
+ cb();
97
+ handleSuccess(options);
183
98
  }
184
- }
185
- async function rejects(block, errorOrMessage, message) {
186
- await (0, exports.processAssert)(async () => {
187
- if (typeof errorOrMessage === 'function' ||
188
- errorOrMessage instanceof RegExp ||
189
- typeof errorOrMessage === 'object') {
190
- await nodeAssert.rejects(block, errorOrMessage, message);
191
- }
192
- else {
193
- const msg = typeof errorOrMessage === 'string' ? errorOrMessage : message;
194
- await nodeAssert.rejects(block, msg);
195
- }
196
- }, {
197
- message: typeof errorOrMessage === 'string' ? errorOrMessage : message,
198
- defaultMessage: 'Expected promise to be rejected with specified error',
199
- hideDiff: true,
200
- throw: true,
201
- });
202
- }
203
- async function doesNotReject(block, errorOrMessage, message) {
204
- await (0, exports.processAssert)(async () => {
205
- if (typeof errorOrMessage === 'function' ||
206
- errorOrMessage instanceof RegExp ||
207
- typeof errorOrMessage === 'object') {
208
- await nodeAssert.doesNotReject(block, errorOrMessage, message);
209
- }
210
- else {
211
- await nodeAssert.doesNotReject(block, message);
212
- }
213
- }, {
214
- message: typeof errorOrMessage === 'string' ? errorOrMessage : message,
215
- defaultMessage: 'Got unwanted rejection',
216
- hideDiff: true,
217
- throw: true,
218
- });
219
- }
220
- const match = (value, regExp, message) => {
221
-
222
- if (typeof get_runtime_js_1.nodeVersion === 'number' && get_runtime_js_1.nodeVersion < 12) {
223
- throw new Error('match is available from Node.js 12 or higher');
99
+ catch (error) {
100
+ handleError(error, options);
224
101
  }
225
- (0, exports.processAssert)(() => nodeAssert === null || nodeAssert === void 0 ? void 0 : nodeAssert.match(value, regExp), {
226
- message,
227
- actual: 'Value',
228
- expected: 'RegExp',
229
- defaultMessage: 'Value should match regExp',
230
- });
231
102
  };
232
- const doesNotMatch = (value, regExp, message) => {
233
-
234
- if (typeof get_runtime_js_1.nodeVersion === 'number' && get_runtime_js_1.nodeVersion < 12) {
235
- throw new Error('doesNotMatch is available from Node.js 12 or higher');
103
+ const processAsyncAssert = async (cb, options) => {
104
+ try {
105
+ await cb();
106
+ handleSuccess(options);
107
+ }
108
+ catch (error) {
109
+ handleError(error, options);
236
110
  }
237
- (0, exports.processAssert)(() => nodeAssert.doesNotMatch(value, regExp), {
238
- message,
239
- actual: 'Value',
240
- expected: 'RegExp',
241
- defaultMessage: 'Value should not match regExp',
242
- });
243
111
  };
244
- const assert = Object.assign((value, message) => ok(value, message), {
245
- ok,
246
- equal,
247
- deepEqual,
248
- strictEqual,
249
- deepStrictEqual,
250
- doesNotMatch,
251
- doesNotReject,
252
- throws,
253
- doesNotThrow,
254
- notEqual,
255
- notDeepEqual,
256
- notStrictEqual,
257
- notDeepStrictEqual,
258
- match,
259
- ifError,
260
- fail,
261
- rejects,
262
- });
263
- return assert;
112
+ return { processAssert, processAsyncAssert };
264
113
  };
265
- exports.createAssert = createAssert;
114
+ _a = assertProcessor(), exports.processAssert = _a.processAssert, exports.processAsyncAssert = _a.processAsyncAssert;
package/lib/services/write.js CHANGED
@@ -7,7 +7,7 @@ exports.Write = {
7
7
  node_process_1.stdout.write(`${String(data)}\n`);
8
8
  },
9
9
  hr: () => {
10
- const line = '⎯'.repeat(node_process_1.stdout.columns - 10 || 40);
10
+ const line = '─'.repeat(node_process_1.stdout.columns - 10 || 40);
11
11
  exports.Write.log(`\n\x1b[2m\x1b[90m${line}\x1b[0m\n`);
12
12
  },
13
13
  };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "poku",
3
- "version": "2.4.1",
3
+ "version": "2.4.3",
4
4
  "description": "🐷 Poku makes testing easy for Node.js, Bun, Deno, and you at the same time.",
5
5
  "main": "./lib/modules/index.js",
6
6
  "license": "MIT",
@@ -65,10 +65,10 @@
65
65
  "@types/node": "^22.1.0",
66
66
  "c8": "^10.1.2",
67
67
  "jsonc.min": "^1.0.0",
68
- "monocart-coverage-reports": "^2.10.1",
68
+ "monocart-coverage-reports": "^2.10.2",
69
69
  "packages-update": "^2.0.0",
70
70
  "prettier": "^3.3.3",
71
- "tsx": "4.16.5",
71
+ "tsx": "4.17.0",
72
72
  "typescript": "^5.5.4"
73
73
  },
74
74
  "keywords": [