@j-o-r/sh 1.1.0 → 1.1.2

package/README.md

@@ -158,14 +158,17 @@ test.add('Test an Array in sync', () => {
 test.add('Test is test in async', async () => {
 	assert.strictEqual(jsType(test), 'Test');
 });
-test.add('Test is test in a promise',
-	new Promise((resolve, _reject) => {
+test.add('Test is test in async, returning a promise', async () => {
+	return new Promise((resolve, _reject) => {
 		assert.strictEqual(jsType(test), 'Test');
 		resolve();
-	})
-)
-
-await test.run();
+	});
+});
+const report = await test.run();
+if (report.errors > 0) {
+  process.exit(1);
+}
+// await test.run([0,3]); // only run test 0 and 3
 ```
 
 ## License

package/lib/SH.js

@@ -23,9 +23,9 @@
 // Changes Made: 
 // - The code has been or is being reformatted to comply with ES2020 standards.
 // - Some methods were added and existing ones were modified or deleted to enhance usability.
-// - Most methods were deleted, 
 // - The namespace has been changed from '$' to 'SH'.
 // Modified by: jorrit.duin+sh[AT]gmail.com
+/** @type {assert} */
 import assert from 'node:assert';
 import SHDispatch from './SHDispatch.js';
 import Test from './Test.js'

package/lib/Test.js

@@ -1,13 +1,17 @@
 import assert from 'node:assert/strict';
 import { jsType } from './SH.js'
-const FNC = ['Function', 'AsyncFunction', 'Promise'];
+const FNC = ['Function', 'AsyncFunction'];
 // Settle async calls in a SYNC function
-const SETTLE_ASYNC = 100;
+const SETTLE_ASYNC = 50;
+
+/**
+* @typedef {(function(): Promise<any>)} AsyncFunction
+*/
 
 /**
 * @typedef {Object} testDefinition
 * @prop {string} description
-* @prop {function|asyncfunction} callback
+* @prop {Function|AsyncFunction} callback - syc/ async function
 */
 
 /**
@@ -25,6 +29,7 @@ const SETTLE_ASYNC = 100;
 */
 /**
 * Get the current time
+* used for calculating a duration
 * @returns {number}
 */
 function getNow() {
@@ -32,7 +37,7 @@ function getNow() {
 }
 
 /**
-* Get the duration
+* Get the duration based on a previous gathered start time
 * @param {number} start - start time
 * @returns {number}
 */
@@ -76,17 +81,17 @@ class Test {
 	*/
 	#detectErrors(active = true) {
 		const errListener = (err) => {
-			this._handleError(err)
+			this.#handleError(err)
 		}
 		if (active) {
 			if (!this.#catchErrors) {
 				process.on('uncaughtException', errListener);
-				this.catchErrors = true;
+				this.#catchErrors = true;
 			}
 		} else {
 			if (this.#catchErrors) {
 				process.removeListener('uncaughtException', errListener);
-				this.catchErrors = false;
+				this.#catchErrors = false;
 			}
 		}
 
@@ -95,7 +100,7 @@ class Test {
 	/**
 	*
 	* @param {string} description
-	* @param {Function|AsyncFunction|Promise} callback
+	* @param {Function|AsyncFunction} callback - sync / async function
 	* @throws Error when conditions are not met
 	*/
 	add(description, callback) {
@@ -103,7 +108,7 @@ class Test {
 			throw new Error(`'description' should be a string`)
 		}
 		if (!FNC.includes(jsType(callback))) {
-			throw new Error(`'callback' should be a (async) function or Promise`)
+			throw new Error(`'callback' should be a (async) Function`)
 		}
 		this.#tests.push({ description, callback });
 	}
@@ -126,6 +131,7 @@ class Test {
 			const type = jsType(cb.callback);
 			let error;
 			try {
+			  if (!this.#quite) process.stdout.write(`${i}. ${cb.description}\n`);
 				if (type === 'Function') {
 					cb.callback();
 					// To settle async calls in sync functions
@@ -133,21 +139,21 @@ class Test {
 					await new Promise(resolve => setTimeout(resolve, this.#TO)); // This will pause the the current loop.
 					// add timeout for an honest execution time
 					start = start + this.#TO;
-				} else if (type === 'Promise') {
-					await Promise.all([cb.callback]);
 				} else {
 					await cb.callback();
 				}
 			} catch (e) {
+          process.stdout.write(`\x1b[31mERROR:  ${i}. ${cb.description}\x1b[0m\n`);
 				if (!errors) {
 					errors = true
 				}
 				error = e;
 			}
 			const duration = getDuration(start);
-			if (!this.#quite) process.stdout.write(`${i}. ${cb.description} : ${duration} ms\n`);
+			if (!this.#quite && !error) process.stdout.write(`Finished in: ${duration} ms\n`);
+			
 			if (error) {
-				this._handleError(error);
+				this.#handleError(error);
 			}
 			this.#reports[i] = { description: cb.description, duration };
 		}
@@ -196,10 +202,12 @@ class Test {
 		this.#errors = [];
 	}
 	/**
+	* @private
 	* Handle an error outside the callstack
 	* for the current test
+	* @param {Error}
 	*/
-	_handleError(err) {
+	#handleError(err) {
 		if (this.#currentTest > -1) {
 			// Register this error
 			// Always print out errors

package/package.json

@@ -2,7 +2,7 @@
   "name": "@j-o-r/sh",
   "author": "Jorrit Duin <j-o-r@duin.work>",
   "type": "module",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Execute shell commands on Linux-based systems from javascript",
   "main": "lib/SH.js",
   "types": "types/SH.d.ts",
@@ -21,7 +21,9 @@
     "url": "https://codeberg.org/duin/sh"
   },
   "license": "Apache License, Version 2.0",
-  "dependencies": {},
+  "dependencies": {
+    "@types/node": "^22.10.10"
+  },
   "bugs": {
     "url": "https://codeberg.org/duin/sh/issues"
   },

package/types/SH.d.ts

@@ -87,9 +87,10 @@ export function parseArgs(args: string[]): object;
 * Determine a javascript type
 *
 * @param {any} fn - Any let type
-* @returns {string} The object / let type name
+* @returns {string} The "real" object / typeof name
 */
 export function jsType(fn: any): string;
 import Test from './Test.js';
+import assert from 'node:assert';
 import SHDispatch from './SHDispatch.js';
 export { Test, assert };

package/types/SHDispatch.d.ts

@@ -36,7 +36,7 @@ export type SHOptions = {
     /**
      * - The environment variables.
      */
-    env?: any;
+    env?: NodeJS.ProcessEnv | undefined;
     /**
      * - The shell to use for execution.
      */

package/types/SHExecute.d.ts

@@ -9,7 +9,7 @@ declare class SHExecute {
     * @param {string} [payload] - data to write
     * @retuns {Promise<object>}
     */
-    runSync(payload?: string | undefined): any;
+    runSync(payload?: string | undefined): import("child_process").SpawnSyncReturns<Buffer> & import("child_process").SpawnSyncReturns<string> & import("child_process").SpawnSyncReturns<string | Buffer>;
     /**
     * @param {string} [payload] - data to write
     * @retuns {Promise<string>}

package/types/Test.d.ts

@@ -1,7 +1,11 @@
 export default Test;
+export type AsyncFunction = (() => Promise<any>);
 export type testDefinition = {
     description: string;
-    callback: Function | asyncfunction;
+    /**
+     * - syc/ async function
+     */
+    callback: Function | AsyncFunction;
 };
 export type testReport = {
     description: string;
@@ -37,14 +41,13 @@ declare class Test {
     * @param {number} timeout - in MS, default 100
     */
     syncTimeout(timeout: number): void;
-    catchErrors: boolean | undefined;
     /**
     *
     * @param {string} description
-    * @param {Function|AsyncFunction|Promise} callback
+    * @param {Function|AsyncFunction} callback - sync / async function
     * @throws Error when conditions are not met
     */
-    add(description: string, callback: Function | AsyncFunction | Promise<any>): void;
+    add(description: string, callback: Function | AsyncFunction): void;
     /**
     * Execute tests
     * @param {number[]} [execute] - limit the execution tests
@@ -55,10 +58,5 @@ declare class Test {
     * Empty tests
     */
     reset(): void;
-    /**
-    * Handle an error outside the callstack
-    * for the current test
-    */
-    _handleError(err: any): void;
     #private;
 }