@decaf-ts/utils 0.10.3 → 0.11.1-0.experimental.1

package/lib/esm/output/common.js

@@ -92,4 +92,4 @@ export function getSlogan(i) {
         throw new Error(`Failed to retrieve slogans: ${error}`);
     }
 }
-//# sourceMappingURL=common.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../src/output/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,+BAA0B;AAC5C,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAG9C;;;;GAIG;AACH,MAAM,MAAM,GAAG;IACb,gBAAgB,EAAE,cAAc;IAChC,gBAAgB,EAAE,QAAQ;IAC1B,gBAAgB,EAAE,OAAO;IACzB,gBAAgB,EAAE,SAAS;IAC3B,gBAAgB,EAAE,SAAS;IAC3B,gBAAgB,EAAE,cAAc;IAChC,gBAAgB,EAAE,cAAc;IAChC,gBAAgB,EAAE,aAAa;IAC/B,gBAAgB,EAAE,aAAa;CAChC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,WAAW,CAAC,MAAe;IACzC,MAAM,OAAO,GAAG,SAAS,EAAE,CAAC;IAC5B,MAAM,MAAM,GACV;;;;;;;EAOF,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACb,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;IAC9E,MAAM,CAAC,IAAI,CAAC,MAAM,OAAO,CAAC,QAAQ,CAAC,SAAS,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;IACrD,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;QAC7B,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAC7D,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAC1C,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,SAAS,CAAC,CAAU;IAClC,IAAI,CAAC;QACH,CAAC;YACC,OAAO,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5E,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IAC3B,CAAC;IAAC,OAAO,KAAc,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,+BAA+B,KAAK,EAAE,CAAC,CAAC;IAC1D,CAAC;AACH,CAAC","sourcesContent":["import { slogans } from \"../assets/slogans\";\nimport { style } from \"styled-string-builder\";\nimport { Logger } from \"@decaf-ts/logging\";\n\n/**\n * @description Array of ANSI color codes for banner styling.\n * @summary Defines a set of ANSI color codes used to style the banner text.\n * @memberOf module:utils\n */\nconst colors = [\n  \"\\x1b[38;5;215m\", // soft orange\n  \"\\x1b[38;5;209m\", // coral\n  \"\\x1b[38;5;205m\", // pink\n  \"\\x1b[38;5;210m\", // peachy\n  \"\\x1b[38;5;217m\", // salmon\n  \"\\x1b[38;5;216m\", // light coral\n  \"\\x1b[38;5;224m\", // light peach\n  \"\\x1b[38;5;230m\", // soft cream\n  \"\\x1b[38;5;230m\", // soft cream\n];\n\n/**\n * @description Prints a styled banner to the console.\n * @summary Generates and prints a colorful ASCII art banner with a random slogan.\n * @param {Logger} [logger] - Optional logger for verbose output.\n * @memberOf module:utils\n * @function printBanner\n * @mermaid\n * sequenceDiagram\n *   participant printBanner\n *   participant getSlogan\n *   participant padEnd\n *   participant console\n *   printBanner->>getSlogan: Call getSlogan()\n *   getSlogan-->>printBanner: Return random slogan\n *   printBanner->>printBanner: Create banner ASCII art\n *   printBanner->>printBanner: Split banner into lines\n *   printBanner->>printBanner: Calculate max line length\n *   printBanner->>padEnd: Call padEnd with slogan\n *   padEnd-->>printBanner: Return padded slogan line\n *   loop For each banner line\n *     printBanner->>style: Call style(line)\n *     style-->>printBanner: Return styled line\n *     printBanner->>console: Log styled line\n *   end\n */\nexport function printBanner(logger?: Logger) {\n  const message = getSlogan();\n  const banner: string | string[] =\n    `#                 ░▒▓███████▓▒░  ░▒▓████████▓▒░  ░▒▓██████▓▒░   ░▒▓██████▓▒░  ░▒▓████████▓▒░       ░▒▓████████▓▒░  ░▒▓███████▓▒░ \n#      ( (        ░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░        ░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░                 ░▒▓█▓▒░     ░▒▓█▓▒░        \n#       ) )       ░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░        ░▒▓█▓▒░        ░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░                 ░▒▓█▓▒░     ░▒▓█▓▒░        \n#    [=======]    ░▒▓█▓▒░░▒▓█▓▒░ ░▒▓██████▓▒░   ░▒▓█▓▒░        ░▒▓████████▓▒░ ░▒▓██████▓▒░            ░▒▓█▓▒░      ░▒▓██████▓▒░  \n#     \\`-----´     ░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░        ░▒▓█▓▒░        ░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░                 ░▒▓█▓▒░            ░▒▓█▓▒░ \n#                 ░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░        ░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░                 ░▒▓█▓▒░            ░▒▓█▓▒░ \n#                 ░▒▓███████▓▒░  ░▒▓████████▓▒░  ░▒▓██████▓▒░  ░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░                 ░▒▓█▓▒░     ░▒▓███████▓▒░  \n#`.split(\"\\n\");\n  const maxLength = banner.reduce((max, line) => Math.max(max, line.length), 0);\n  banner.push(`#  ${message.padStart(maxLength - 3)}`);\n  banner.forEach((line, index) => {\n    (logger ? logger.info.bind(logger) : console.log.bind(console))(\n      style(line || \"\").raw(colors[index]).text\n    );\n  });\n}\n\n/**\n * @description Retrieves a slogan from the predefined list.\n * @summary Fetches a random slogan or a specific one by index from the slogans list.\n * @param {number} [i] - Optional index to retrieve a specific slogan.\n * @return {string} The selected slogan.\n * @function getSlogan\n * @memberOf module:utils\n * @mermaid\n * sequenceDiagram\n *   participant getSlogan\n *   participant Math.random\n *   participant slogans\n *   alt i is undefined\n *     getSlogan->>Math.random: Generate random index\n *     Math.random-->>getSlogan: Return random index\n *   else i is defined\n *     Note over getSlogan: Use provided index\n *   end\n *   getSlogan->>slogans: Access slogan at index\n *   slogans-->>getSlogan: Return slogan\n *   alt Error occurs\n *     getSlogan->>getSlogan: Throw error\n *   end\n *   getSlogan-->>Caller: Return slogan\n */\nexport function getSlogan(i?: number): string {\n  try {\n    i =\n      typeof i === \"undefined\" ? Math.floor(Math.random() * slogans.length) : i;\n    return slogans[i].Slogan;\n  } catch (error: unknown) {\n    throw new Error(`Failed to retrieve slogans: ${error}`);\n  }\n}\n"]}

package/lib/esm/output/index.js

@@ -1,2 +1,2 @@
 export * from "./common.js";
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvb3V0cHV0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDRCQUF5QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NvbW1vblwiO1xuIl19

package/lib/esm/tests/Consumer.d.ts

@@ -1,24 +1,96 @@
 import { LoggedClass } from "@decaf-ts/logging";
 import { TestReporter } from "./TestReporter";
+/**
+ * @description Store for logs indexed by identifier.
+ * @summary A record where keys are identifiers and values are arrays of log strings.
+ * @typedef {Record<number, string[]>} LogStore
+ * @memberOf module:utils
+ */
 type LogStore = Record<number, string[]>;
+/**
+ * @description Structure of a parsed log entry.
+ * @summary Contains timestamp, child identifier, and action.
+ * @interface ParsedLog
+ * @property {number} timestamp - The timestamp of the log.
+ * @property {string} child - The child identifier.
+ * @property {string} action - The action performed.
+ * @memberOf module:utils
+ */
 export interface ParsedLog {
     timestamp: number;
     child: string;
     action: string;
 }
+/**
+ * @description Result of a comparison between consumer and producer logs.
+ * @summary Contains arrays of parsed logs for both consumer and producer.
+ * @interface ComparerResult
+ * @property {ParsedLog[]} consumer - The parsed consumer logs.
+ * @property {ParsedLog[]} producer - The parsed producer logs.
+ * @memberOf module:utils
+ */
 export interface ComparerResult {
     consumer: ParsedLog[];
     producer: ParsedLog[];
 }
+/**
+ * @description Function type for comparing consumer and producer data.
+ * @summary Compares two LogStores and returns a Promise resolving to ComparerResult.
+ * @typedef {function(LogStore, LogStore): Promise<ComparerResult>} Comparer
+ * @memberOf module:utils
+ */
 type Comparer = (consumerData: LogStore, producerData: LogStore) => Promise<ComparerResult>;
+/**
+ * @description Function type for handling consumer actions.
+ * @summary A function that takes an identifier and optional arguments, returning a result.
+ * @typedef {function(number, ...unknown[]): unknown | Promise<unknown>} ConsumerHandler
+ * @memberOf module:utils
+ */
 type ConsumerHandler = (identifier: number, ...args: unknown[]) => unknown | Promise<unknown>;
+/**
+ * @description Default comparer function for consumer and producer logs.
+ * @summary Sorts and compares consumer and producer logs to ensure they match.
+ * @param {LogStore} consumerData - The consumer logs.
+ * @param {LogStore} producerData - The producer logs.
+ * @return {Promise<ComparerResult>} The comparison result.
+ * @function defaultComparer
+ * @memberOf module:utils
+ */
 export declare const defaultComparer: Comparer;
+/**
+ * @description Options for the reporting comparer.
+ * @summary Configuration options for the reportingComparer function.
+ * @interface ReportingComparerOptions
+ * @property {TestReporter} [reporter] - The test reporter instance.
+ * @property {string} [testCase] - The test case name.
+ * @property {string} [referencePrefix] - The prefix for report references.
+ * @memberOf module:utils
+ */
 export interface ReportingComparerOptions {
     reporter?: TestReporter;
     testCase?: string;
     referencePrefix?: string;
 }
+/**
+ * @description Comparer function that reports results using TestReporter.
+ * @summary Compares logs and generates a report with tables and messages.
+ * @param {LogStore} consumerData - The consumer logs.
+ * @param {LogStore} producerData - The producer logs.
+ * @param {ReportingComparerOptions} [options] - Options for reporting.
+ * @return {Promise<ComparerResult>} The comparison result.
+ * @function reportingComparer
+ * @memberOf module:utils
+ */
 export declare const reportingComparer: (consumerData: LogStore, producerData: LogStore, options?: ReportingComparerOptions) => Promise<ComparerResult>;
+/**
+ * @class ConsumerRunner
+ * @description Runs a consumer process and manages producer child processes.
+ * @summary Orchestrates the execution of consumer and producer processes, collects logs, and compares results.
+ * @param {string} action - The action name.
+ * @param {ConsumerHandler} consumerHandler - The handler function for the consumer.
+ * @param {Comparer} [compareHandler] - Optional custom comparer function.
+ * @memberOf module:utils
+ */
 export declare class ConsumerRunner extends LoggedClass {
     private readonly action;
     private readonly handler;
@@ -40,6 +112,40 @@ export declare class ConsumerRunner extends LoggedClass {
     private isProducerComplete;
     private isConsumerComplete;
     private terminateChildren;
+    /**
+     * @description Runs the consumer and producer processes.
+     * @summary Starts the producer child processes and the consumer handler, then waits for completion and compares results.
+     * @param {number} count - The number of producers.
+     * @param {number} [timeout] - The timeout for producers.
+     * @param {number} times - The number of times to repeat.
+     * @param {boolean} [random] - Whether to use random timeouts.
+     * @return {Promise<ComparerResult>} The comparison result.
+     * @mermaid
+     * sequenceDiagram
+     *   participant Runner as ConsumerRunner
+     *   participant Child as ProducerChild
+     *   participant Handler as ConsumerHandler
+     *   participant Comparer as Comparer
+     *   Runner->>Runner: reset()
+     *   loop For each count
+     *     Runner->>Child: fork()
+     *     Runner->>Runner: Store child process
+     *   end
+     *   Runner->>Child: send(start message)
+     *   loop For each message from Child
+     *     Child->>Runner: message(action)
+     *     Runner->>Runner: store producer log
+     *     Runner->>Handler: call handler
+     *     Handler-->>Runner: return
+     *     Runner->>Runner: record consumer log
+     *     Runner->>Runner: finalizeIfComplete()
+     *   end
+     *   alt Complete
+     *     Runner->>Comparer: compare logs
+     *     Comparer-->>Runner: return result
+     *     Runner-->>Caller: resolve(result)
+     *   end
+     */
     run(count: number, timeout: number | undefined, times: number, random: boolean | undefined): Promise<ComparerResult>;
 }
 export {};

package/lib/esm/tests/Consumer.js

@@ -2,6 +2,14 @@ import { fork } from "node:child_process";
 import { join } from "node:path";
 import { LoggedClass } from "@decaf-ts/logging";
 import { TestReporter } from "./TestReporter.js";
+/**
+ * @description Parses a log string into a ParsedLog object.
+ * @summary Splits the log string by " - " and extracts timestamp, child, and action.
+ * @param {string} data - The log string to parse.
+ * @return {ParsedLog} The parsed log object.
+ * @function parseData
+ * @memberOf module:utils
+ */
 const parseData = (data) => {
     const [timestamp, , child, action] = data.split(" - ");
     return {
@@ -10,6 +18,15 @@ const parseData = (data) => {
         action,
     };
 };
+/**
+ * @description Default comparer function for consumer and producer logs.
+ * @summary Sorts and compares consumer and producer logs to ensure they match.
+ * @param {LogStore} consumerData - The consumer logs.
+ * @param {LogStore} producerData - The producer logs.
+ * @return {Promise<ComparerResult>} The comparison result.
+ * @function defaultComparer
+ * @memberOf module:utils
+ */
 export const defaultComparer = async (consumerData, producerData) => {
     const sortedConsumerData = Object.keys(consumerData)
         .reduce((accum, key) => {
@@ -56,7 +73,25 @@ export const defaultComparer = async (consumerData, producerData) => {
         producer: sortedProducerData,
     };
 };
+/**
+ * @description Formats a timestamp into an ISO string.
+ * @summary Converts a numeric timestamp to an ISO 8601 string.
+ * @param {number} value - The timestamp to format.
+ * @return {string} The formatted date string.
+ * @function formatTimestamp
+ * @memberOf module:utils
+ */
 const formatTimestamp = (value) => new Date(value).toISOString();
+/**
+ * @description Comparer function that reports results using TestReporter.
+ * @summary Compares logs and generates a report with tables and messages.
+ * @param {LogStore} consumerData - The consumer logs.
+ * @param {LogStore} producerData - The producer logs.
+ * @param {ReportingComparerOptions} [options] - Options for reporting.
+ * @return {Promise<ComparerResult>} The comparison result.
+ * @function reportingComparer
+ * @memberOf module:utils
+ */
 export const reportingComparer = async (consumerData, producerData, options) => {
     const reporter = options?.reporter ??
         new TestReporter(options?.testCase ?? "consumer-producer");
@@ -104,6 +139,15 @@ export const reportingComparer = async (consumerData, producerData, options) =>
         throw error;
     }
 };
+/**
+ * @class ConsumerRunner
+ * @description Runs a consumer process and manages producer child processes.
+ * @summary Orchestrates the execution of consumer and producer processes, collects logs, and compares results.
+ * @param {string} action - The action name.
+ * @param {ConsumerHandler} consumerHandler - The handler function for the consumer.
+ * @param {Comparer} [compareHandler] - Optional custom comparer function.
+ * @memberOf module:utils
+ */
 export class ConsumerRunner extends LoggedClass {
     constructor(action, consumerHandler, compareHandler) {
         super();
@@ -213,6 +257,40 @@ export class ConsumerRunner extends LoggedClass {
         });
         return this.waitForChildExit();
     }
+    /**
+     * @description Runs the consumer and producer processes.
+     * @summary Starts the producer child processes and the consumer handler, then waits for completion and compares results.
+     * @param {number} count - The number of producers.
+     * @param {number} [timeout] - The timeout for producers.
+     * @param {number} times - The number of times to repeat.
+     * @param {boolean} [random] - Whether to use random timeouts.
+     * @return {Promise<ComparerResult>} The comparison result.
+     * @mermaid
+     * sequenceDiagram
+     *   participant Runner as ConsumerRunner
+     *   participant Child as ProducerChild
+     *   participant Handler as ConsumerHandler
+     *   participant Comparer as Comparer
+     *   Runner->>Runner: reset()
+     *   loop For each count
+     *     Runner->>Child: fork()
+     *     Runner->>Runner: Store child process
+     *   end
+     *   Runner->>Child: send(start message)
+     *   loop For each message from Child
+     *     Child->>Runner: message(action)
+     *     Runner->>Runner: store producer log
+     *     Runner->>Handler: call handler
+     *     Handler-->>Runner: return
+     *     Runner->>Runner: record consumer log
+     *     Runner->>Runner: finalizeIfComplete()
+     *   end
+     *   alt Complete
+     *     Runner->>Comparer: compare logs
+     *     Comparer-->>Runner: return result
+     *     Runner-->>Caller: resolve(result)
+     *   end
+     */
     async run(count, timeout, times, random) {
         this.reset();
         this.expectedIterations = times;
@@ -322,4 +400,4 @@ export class ConsumerRunner extends LoggedClass {
         });
     }
 }
-//# sourceMappingURL=Consumer.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Consumer.js","sourceRoot":"","sources":["../../../src/tests/Consumer.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChildProcess, fork } from \"node:child_process\";\nimport { join } from \"node:path\";\nimport { LoggedClass } from \"@decaf-ts/logging\";\nimport { TestReporter } from \"./TestReporter\";\n\n/**\n * @description Store for logs indexed by identifier.\n * @summary A record where keys are identifiers and values are arrays of log strings.\n * @typedef {Record<number, string[]>} LogStore\n * @memberOf module:utils\n */\ntype LogStore = Record<number, string[]>;\n\n/**\n * @description Structure of a parsed log entry.\n * @summary Contains timestamp, child identifier, and action.\n * @interface ParsedLog\n * @property {number} timestamp - The timestamp of the log.\n * @property {string} child - The child identifier.\n * @property {string} action - The action performed.\n * @memberOf module:utils\n */\nexport interface ParsedLog {\n  timestamp: number;\n  child: string;\n  action: string;\n}\n\n/**\n * @description Result of a comparison between consumer and producer logs.\n * @summary Contains arrays of parsed logs for both consumer and producer.\n * @interface ComparerResult\n * @property {ParsedLog[]} consumer - The parsed consumer logs.\n * @property {ParsedLog[]} producer - The parsed producer logs.\n * @memberOf module:utils\n */\nexport interface ComparerResult {\n  consumer: ParsedLog[];\n  producer: ParsedLog[];\n}\n\n/**\n * @description Function type for comparing consumer and producer data.\n * @summary Compares two LogStores and returns a Promise resolving to ComparerResult.\n * @typedef {function(LogStore, LogStore): Promise<ComparerResult>} Comparer\n * @memberOf module:utils\n */\ntype Comparer = (\n  consumerData: LogStore,\n  producerData: LogStore\n) => Promise<ComparerResult>;\n\n/**\n * @description Function type for handling consumer actions.\n * @summary A function that takes an identifier and optional arguments, returning a result.\n * @typedef {function(number, ...unknown[]): unknown | Promise<unknown>} ConsumerHandler\n * @memberOf module:utils\n */\ntype ConsumerHandler = (\n  identifier: number,\n  ...args: unknown[]\n) => unknown | Promise<unknown>;\n\n/**\n * @description Message structure sent to the producer child process.\n * @summary Defines the properties of a message sent to control the producer.\n * @interface ProducerMessage\n * @property {number} identifier - The identifier of the producer.\n * @property {string[]} [result] - Optional result logs.\n * @property {unknown[]} [args] - Optional arguments.\n * @property {string} action - The action to perform.\n * @property {number} [timeout] - Optional timeout.\n * @property {number} times - Number of times to repeat.\n * @property {boolean} [random] - Whether to use random timeouts.\n * @memberOf module:utils\n */\ninterface ProducerMessage {\n  identifier: number;\n  result?: string[];\n  args?: unknown[];\n  action: string;\n  timeout?: number;\n  times: number;\n  random?: boolean;\n}\n\n/**\n * @description Parses a log string into a ParsedLog object.\n * @summary Splits the log string by \" - \" and extracts timestamp, child, and action.\n * @param {string} data - The log string to parse.\n * @return {ParsedLog} The parsed log object.\n * @function parseData\n * @memberOf module:utils\n */\nconst parseData = (data: string): ParsedLog => {\n  const [timestamp, , child, action] = data.split(\" - \");\n  return {\n    timestamp: parseInt(timestamp, 10),\n    child,\n    action,\n  };\n};\n\n/**\n * @description Default comparer function for consumer and producer logs.\n * @summary Sorts and compares consumer and producer logs to ensure they match.\n * @param {LogStore} consumerData - The consumer logs.\n * @param {LogStore} producerData - The producer logs.\n * @return {Promise<ComparerResult>} The comparison result.\n * @function defaultComparer\n * @memberOf module:utils\n */\nexport const defaultComparer: Comparer = async (consumerData, producerData) => {\n  const sortedConsumerData = Object.keys(consumerData)\n    .reduce<ParsedLog[]>((accum, key) => {\n      const identifier = Number(key);\n      const entries = consumerData[identifier] ?? [];\n      accum.push(...entries.map((entry) => parseData(entry)));\n      return accum;\n    }, [])\n    .sort((a, b) => a.timestamp - b.timestamp);\n\n  const sortedProducerData = Object.keys(producerData)\n    .reduce<ParsedLog[]>((accum, key) => {\n      const identifier = Number(key);\n      const entries = producerData[identifier] ?? [];\n      accum.push(...entries.map((entry) => parseData(entry)));\n      return accum;\n    }, [])\n    .sort((a, b) => a.timestamp - b.timestamp);\n\n  if (sortedProducerData.length !== sortedConsumerData.length) {\n    throw new Error(\"Producer data and consumer data does not match in length\");\n  }\n\n  let counter = -1;\n  const isMatching = sortedProducerData.every((producer, index) => {\n    counter = index;\n    const consumer = sortedConsumerData[index];\n    return (\n      producer.child === consumer.child && producer.action === consumer.action\n    );\n  });\n\n  if (!isMatching) {\n    const errorLines = [\n      `Producer data and consumer data do not sort the same way as of record ${counter}:`,\n      \"    |             CONSUMER            |              PRODUCER            |\",\n      \"    | id | action    | timestamp      | id | action    | timestamp       |\",\n    ];\n\n    sortedProducerData.forEach((producer, index) => {\n      if (index < counter || index > counter + 15) {\n        return;\n      }\n      const consumer = sortedConsumerData[index];\n      errorLines.push(\n        `  ${index < 10 ? `0${index}` : index}|  ${consumer.child} | ${consumer.action}    | ${consumer.timestamp}  | ${producer.child}  | ${producer.action}    | ${producer.timestamp}   |`\n      );\n    });\n\n    throw new Error(errorLines.join(\"\\n\"));\n  }\n\n  return {\n    consumer: sortedConsumerData,\n    producer: sortedProducerData,\n  };\n};\n\n/**\n * @description Options for the reporting comparer.\n * @summary Configuration options for the reportingComparer function.\n * @interface ReportingComparerOptions\n * @property {TestReporter} [reporter] - The test reporter instance.\n * @property {string} [testCase] - The test case name.\n * @property {string} [referencePrefix] - The prefix for report references.\n * @memberOf module:utils\n */\nexport interface ReportingComparerOptions {\n  reporter?: TestReporter;\n  testCase?: string;\n  referencePrefix?: string;\n}\n\n/**\n * @description Formats a timestamp into an ISO string.\n * @summary Converts a numeric timestamp to an ISO 8601 string.\n * @param {number} value - The timestamp to format.\n * @return {string} The formatted date string.\n * @function formatTimestamp\n * @memberOf module:utils\n */\nconst formatTimestamp = (value: number): string =>\n  new Date(value).toISOString();\n\n/**\n * @description Comparer function that reports results using TestReporter.\n * @summary Compares logs and generates a report with tables and messages.\n * @param {LogStore} consumerData - The consumer logs.\n * @param {LogStore} producerData - The producer logs.\n * @param {ReportingComparerOptions} [options] - Options for reporting.\n * @return {Promise<ComparerResult>} The comparison result.\n * @function reportingComparer\n * @memberOf module:utils\n */\nexport const reportingComparer = async (\n  consumerData: LogStore,\n  producerData: LogStore,\n  options?: ReportingComparerOptions\n): Promise<ComparerResult> => {\n  const reporter =\n    options?.reporter ??\n    new TestReporter(options?.testCase ?? \"consumer-producer\");\n  const referencePrefix = options?.referencePrefix ?? \"consumer-producer\";\n\n  try {\n    const comparison = await defaultComparer(consumerData, producerData);\n\n    const rows = comparison.consumer.map((consumerEntry, index) => {\n      const producerEntry = comparison.producer[index];\n      return {\n        Index: `${index}`,\n        \"Consumer Child\": consumerEntry.child,\n        \"Consumer Action\": consumerEntry.action,\n        \"Consumer Timestamp\": formatTimestamp(consumerEntry.timestamp),\n        \"Producer Child\": producerEntry?.child ?? \"N/A\",\n        \"Producer Action\": producerEntry?.action ?? \"N/A\",\n        \"Producer Timestamp\": producerEntry\n          ? formatTimestamp(producerEntry.timestamp)\n          : \"N/A\",\n      };\n    });\n\n    await Promise.allSettled([\n      reporter.reportMessage(\n        `${referencePrefix}-comparison`,\n        `Consumer and producer logs matched (${comparison.consumer.length} entries).`\n      ),\n      reporter.reportTable(`${referencePrefix}-logs`, {\n        headers: [\n          \"Index\",\n          \"Consumer Child\",\n          \"Consumer Action\",\n          \"Consumer Timestamp\",\n          \"Producer Child\",\n          \"Producer Action\",\n          \"Producer Timestamp\",\n        ],\n        rows,\n      }),\n    ]);\n\n    return comparison;\n  } catch (error) {\n    const message =\n      error instanceof Error ? error.message : String(error ?? \"Unknown error\");\n\n    await Promise.allSettled([\n      reporter.reportMessage(`${referencePrefix}-mismatch`, message),\n      reporter.reportObject(`${referencePrefix}-consumer`, consumerData),\n      reporter.reportObject(`${referencePrefix}-producer`, producerData),\n    ]);\n\n    throw error;\n  }\n};\n\n/**\n * @class ConsumerRunner\n * @description Runs a consumer process and manages producer child processes.\n * @summary Orchestrates the execution of consumer and producer processes, collects logs, and compares results.\n * @param {string} action - The action name.\n * @param {ConsumerHandler} consumerHandler - The handler function for the consumer.\n * @param {Comparer} [compareHandler] - Optional custom comparer function.\n * @memberOf module:utils\n */\nexport class ConsumerRunner extends LoggedClass {\n  private readonly action: string;\n  private readonly handler: ConsumerHandler;\n  private readonly comparerHandle: Comparer;\n  private forkedCache: ChildProcess[] | undefined = [];\n  private consumerResults: LogStore = {};\n  private producerResults: LogStore = {};\n  private childExitPromises: Array<Promise<void>> = [];\n  private completionTriggered = false;\n  private producerCompletion = 0;\n  private consumerCompletion = 0;\n  private expectedIterations = 0;\n  private activeHandlers = 0;\n\n  constructor(\n    action: string,\n    consumerHandler: ConsumerHandler,\n    compareHandler?: Comparer\n  ) {\n    super();\n    this.action = action;\n    this.handler = consumerHandler;\n    this.comparerHandle = compareHandler ?? defaultComparer;\n    this.reset();\n  }\n\n  private reset(): void {\n    this.forkedCache = [];\n    this.consumerResults = {};\n    this.producerResults = {};\n    this.completionTriggered = false;\n    this.childExitPromises = [];\n    this.activeHandlers = 0;\n    this.producerCompletion = 0;\n    this.consumerCompletion = 0;\n    this.expectedIterations = 0;\n  }\n\n  private waitForChildExit(): Promise<void> {\n    if (!this.childExitPromises?.length) {\n      return Promise.resolve();\n    }\n    const exits = [...this.childExitPromises];\n    this.childExitPromises = [];\n    return Promise.allSettled(exits).then(() => void 0);\n  }\n\n  private store(\n    identifier: number,\n    action: string,\n    timeout: number | undefined,\n    times: number,\n    count: number,\n    random?: boolean\n  ): void {\n    const logParts: Array<string | number | boolean> = [\n      Date.now(),\n      \"PRODUCER\",\n      identifier,\n      action,\n    ];\n    if (timeout) {\n      logParts.push(timeout);\n    }\n    if (times && count) {\n      logParts.push(`${count}/${times}`, random ?? false);\n    }\n\n    const log = logParts.join(\" - \");\n    if (!this.producerResults[identifier]) {\n      this.producerResults[identifier] = [];\n    }\n    const logs = this.producerResults[identifier];\n    logs.push(log);\n    const totalTimes = times ?? this.expectedIterations;\n    if (totalTimes > 0 && logs.length === totalTimes) {\n      this.producerCompletion += 1;\n    }\n  }\n\n  private recordConsumer(identifier: number, times?: number): void {\n    const logParts: Array<string | number> = [\n      Date.now(),\n      \"CONSUMER\",\n      identifier,\n      this.action,\n    ];\n    const log = logParts.join(\" - \");\n\n    if (!this.consumerResults[identifier]) {\n      this.consumerResults[identifier] = [];\n    }\n    const logs = this.consumerResults[identifier];\n    logs.push(log);\n    const totalTimes = times ?? this.expectedIterations;\n    if (totalTimes > 0 && logs.length === totalTimes) {\n      this.consumerCompletion += 1;\n    }\n  }\n\n  private isProducerComplete(count: number): boolean {\n    return this.producerCompletion >= count;\n  }\n\n  private isConsumerComplete(count: number): boolean {\n    return this.consumerCompletion >= count;\n  }\n\n  private terminateChildren(forceKill = false): Promise<void> {\n    if (!this.forkedCache) {\n      return this.waitForChildExit();\n    }\n    const cached = this.forkedCache;\n    this.forkedCache = undefined;\n    cached.forEach((forked, index) => {\n      if (!forked.connected && !forceKill) {\n        return;\n      }\n      try {\n        forked.send({\n          identifier: index,\n          terminate: true,\n        });\n      } catch {\n        // IPC channel already closed; nothing else to do.\n      }\n      if (forceKill && !forked.killed) {\n        forked.kill();\n      }\n    });\n    return this.waitForChildExit();\n  }\n\n  /**\n   * @description Runs the consumer and producer processes.\n   * @summary Starts the producer child processes and the consumer handler, then waits for completion and compares results.\n   * @param {number} count - The number of producers.\n   * @param {number} [timeout] - The timeout for producers.\n   * @param {number} times - The number of times to repeat.\n   * @param {boolean} [random] - Whether to use random timeouts.\n   * @return {Promise<ComparerResult>} The comparison result.\n   * @mermaid\n   * sequenceDiagram\n   *   participant Runner as ConsumerRunner\n   *   participant Child as ProducerChild\n   *   participant Handler as ConsumerHandler\n   *   participant Comparer as Comparer\n   *   Runner->>Runner: reset()\n   *   loop For each count\n   *     Runner->>Child: fork()\n   *     Runner->>Runner: Store child process\n   *   end\n   *   Runner->>Child: send(start message)\n   *   loop For each message from Child\n   *     Child->>Runner: message(action)\n   *     Runner->>Runner: store producer log\n   *     Runner->>Handler: call handler\n   *     Handler-->>Runner: return\n   *     Runner->>Runner: record consumer log\n   *     Runner->>Runner: finalizeIfComplete()\n   *   end\n   *   alt Complete\n   *     Runner->>Comparer: compare logs\n   *     Comparer-->>Runner: return result\n   *     Runner-->>Caller: resolve(result)\n   *   end\n   */\n  async run(\n    count: number,\n    timeout: number | undefined,\n    times: number,\n    random: boolean | undefined\n  ): Promise<ComparerResult> {\n    this.reset();\n    this.expectedIterations = times;\n    const childPath = join(__dirname, \"ProducerChildProcess.cjs\");\n\n    return new Promise<ComparerResult>((resolve, reject) => {\n      const snapshotState = () => {\n        const summarize = (records: LogStore) =>\n          Object.keys(records).reduce<Record<string, number>>((acc, key) => {\n            acc[key] = records[Number(key)]?.length ?? 0;\n            return acc;\n          }, {});\n        return {\n          producers: summarize(this.producerResults),\n          consumers: summarize(this.consumerResults),\n          activeHandlers: this.activeHandlers,\n        };\n      };\n\n      const handleError = (error: unknown) => {\n        if (this.completionTriggered) {\n          return;\n        }\n        this.completionTriggered = true;\n        Promise.resolve(this.terminateChildren(true)).finally(() =>\n          reject(error)\n        );\n      };\n\n      const finalizeIfComplete = () => {\n        if (this.completionTriggered) {\n          return;\n        }\n        if (\n          !this.isProducerComplete(count) ||\n          !this.isConsumerComplete(count) ||\n          this.activeHandlers > 0\n        ) {\n          return;\n        }\n\n        this.completionTriggered = true;\n        if (process.env.DEBUG_CONSUMER_RUNNER === \"1\") {\n          console.debug(\"ConsumerRunner finalize state\", snapshotState());\n        }\n\n        try {\n          const comparisonPromise = Promise.resolve(\n            this.comparerHandle(this.consumerResults, this.producerResults)\n          );\n          Promise.all([comparisonPromise, this.waitForChildExit()])\n            .then(async ([comparison]) => {\n              await new Promise((resolveDelay) => setImmediate(resolveDelay));\n              resolve(comparison);\n            })\n            .catch(reject);\n        } catch (error) {\n          reject(error);\n        }\n      };\n\n      for (let identifier = 1; identifier < count + 1; identifier += 1) {\n        const forked = fork(childPath);\n        this.forkedCache?.push(forked);\n        this.childExitPromises?.push(\n          new Promise<void>((resolveChild) => {\n            forked.once(\"exit\", () => resolveChild());\n          })\n        );\n\n        forked.on(\"error\", handleError);\n\n        forked.on(\"message\", async (message: ProducerMessage) => {\n          if (this.completionTriggered) {\n            return;\n          }\n          const {\n            identifier: childId,\n            args,\n            action,\n            timeout: childTimeout,\n            times: childTimes,\n            random: childRandom,\n          } = message;\n\n          this.activeHandlers += 1;\n          let handlerFailed = false;\n          if (process.env.DEBUG_CONSUMER_RUNNER === \"1\") {\n            console.debug(\"ConsumerRunner message:start\", {\n              childId,\n              producerCount: this.producerResults[childId]?.length ?? 0,\n              consumerCount: this.consumerResults[childId]?.length ?? 0,\n              activeHandlers: this.activeHandlers,\n            });\n          }\n          try {\n            this.store(\n              childId,\n              action,\n              childTimeout,\n              childTimes,\n              count,\n              childRandom\n            );\n            const handlerArgs = Array.isArray(args) ? args : [];\n            await Promise.resolve(this.handler(childId, ...handlerArgs));\n\n            this.recordConsumer(childId, childTimes ?? times);\n            if (process.env.DEBUG_CONSUMER_RUNNER === \"1\") {\n              console.debug(\"ConsumerRunner message:complete\", {\n                childId,\n                producerCount: this.producerResults[childId]?.length ?? 0,\n                consumerCount: this.consumerResults[childId]?.length ?? 0,\n                activeHandlers: this.activeHandlers,\n              });\n            }\n          } catch (error) {\n            handlerFailed = true;\n            handleError(error);\n          } finally {\n            this.activeHandlers = Math.max(0, this.activeHandlers - 1);\n            if (!handlerFailed) {\n              finalizeIfComplete();\n            }\n          }\n        });\n      }\n\n      this.forkedCache?.forEach((forked, index) => {\n        forked.send({\n          identifier: index,\n          action: this.action,\n          timeout,\n          times,\n          random,\n        });\n      });\n    });\n  }\n}\n"]}

package/lib/esm/tests/ProducerChildProcess.js

@@ -63,4 +63,4 @@ process.on("message", (args) => {
     };
     iterator();
 });
-//# sourceMappingURL=ProducerChildProcess.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/tests/TestReporter.d.ts

@@ -121,6 +121,9 @@ export declare class TestReporter {
      * @return {Promise<void>} Promise that resolves when helpers are imported
      */
     private importHelpers;
+    private getJestHtmlReportersTempDir;
+    private ensureJestHtmlReportersTempDirs;
+    private overrideJestHtmlReportersTempPaths;
     /**
      * @description Reports a message to the test report
      * @summary Adds a formatted message to the test report with an optional title

package/lib/esm/tests/TestReporter.js

@@ -101,13 +101,31 @@ export class TestReporter {
      * @return {Promise<void>} Promise that resolves when helpers are imported
      */
     async importHelpers() {
+        this.ensureJestHtmlReportersTempDirs();
         this.deps = await installIfNotAvailable([dependencies[0]], this.deps);
         // if (!process.env[JestReportersTempPathEnvKey])
         //   process.env[JestReportersTempPathEnvKey] = './workdocs/reports';
-        const { addMsg, addAttach } = await normalizeImport(import(`${dependencies[0]}/helper`));
+        const helper = await normalizeImport(import(`${dependencies[0]}/helper`));
+        const { addMsg, addAttach } = helper;
+        this.overrideJestHtmlReportersTempPaths(helper);
         TestReporter.addMsgFunction = addMsg;
         TestReporter.addAttachFunction = addAttach;
     }
+    getJestHtmlReportersTempDir() {
+        return (process.env[JestReportersTempPathEnvKey] ||
+            path.join(this.basePath, "jest-html-reporters-temp"));
+    }
+    ensureJestHtmlReportersTempDirs() {
+        const tempDir = this.getJestHtmlReportersTempDir();
+        fs.mkdirSync(path.join(tempDir, "data"), { recursive: true });
+        fs.mkdirSync(path.join(tempDir, "images"), { recursive: true });
+    }
+    overrideJestHtmlReportersTempPaths(helper) {
+        const tempDir = this.getJestHtmlReportersTempDir();
+        helper.tempDirPath = tempDir;
+        helper.dataDirPath = path.join(tempDir, "data");
+        helper.attachDirPath = path.join(tempDir, "images");
+    }
     /**
      * @description Reports a message to the test report
      * @summary Adds a formatted message to the test report with an optional title
@@ -257,4 +275,4 @@ export class TestReporter {
         return this.report(reference, buffer, "image");
     }
 }
-//# sourceMappingURL=TestReporter.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TestReporter.js","sourceRoot":"","sources":["../../../src/tests/TestReporter.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,EAAE,qBAAqB,EAAE,yBAAoB;AAoCpD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,mCAAmC,CAAC;AAE/E;;;;;GAKG;AACH,MAAM,YAAY,GAAG,CAAC,qBAAqB,EAAE,SAAS,EAAE,qBAAqB,CAAC,CAAC;AAE/E;;;;;;;;GAQG;AACH,KAAK,UAAU,eAAe,CAAI,aAAyB;IACzD,mEAAmE;IACnE,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,CAAM,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,MAAM,OAAO,YAAY;IAwBvB,YACY,WAAmB,OAAO,EAC1B,WAAW,IAAI,CAAC,IAAI,CAC5B,OAAO,CAAC,GAAG,EAAE,EACb,UAAU,EACV,SAAS,EACT,WAAW,CACZ;QANS,aAAQ,GAAR,QAAQ,CAAkB;QAC1B,aAAQ,GAAR,QAAQ,CAKjB;QAED,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QACnD,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YAClC,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,aAAa;QACzB,IAAI,CAAC,+BAA+B,EAAE,CAAC;QACvC,IAAI,CAAC,IAAI,GAAG,MAAM,qBAAqB,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QACtE,iDAAiD;QACjD,qEAAqE;QACrE,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;QAC1E,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,MAM7B,CAAC;QACF,IAAI,CAAC,kCAAkC,CAAC,MAAiC,CAAC,CAAC;QAC3E,YAAY,CAAC,cAAc,GAAG,MAAM,CAAC;QACrC,YAAY,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAC7C,CAAC;IAEO,2BAA2B;QACjC,OAAO,CACL,OAAO,CAAC,GAAG,CAAC,2BAA2B,CAAC;YACxC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,0BAA0B,CAAC,CACrD,CAAC;IACJ,CAAC;IAEO,+BAA+B;QACrC,MAAM,OAAO,GAAG,IAAI,CAAC,2BAA2B,EAAE,CAAC;QACnD,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC9D,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAClE,CAAC;IAEO,kCAAkC,CAAC,MAA+B;QACxE,MAAM,OAAO,GAAG,IAAI,CAAC,2BAA2B,EAAE,CAAC;QACnD,MAAM,CAAC,WAAW,GAAG,OAAO,CAAC;QAC7B,MAAM,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAChD,MAAM,CAAC,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IACtD,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,aAAa,CAAC,KAAa,EAAE,OAAwB;QACzD,IAAI,CAAC,YAAY,CAAC,cAAc;YAAE,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;QAC7D,MAAM,GAAG,GAAG,GAAG,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;QACvD,MAAM,YAAY,CAAC,cAAc,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC;IACtD,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,gBAAgB,CACpB,KAAa,EACb,UAA2B;QAE3B,IAAI,CAAC,YAAY,CAAC,iBAAiB;YAAE,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;QAChE,MAAM,YAAY,CAAC,iBAAiB,CAAC;YACnC,MAAM,EAAE,UAAU;YAClB,WAAW,EAAE,KAAK;SACnB,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACO,KAAK,CAAC,MAAM,CACpB,SAAiB,EACjB,IAAuC,EACvC,IAAiB,EACjB,OAAgB,KAAK;QAErB,IAAI,CAAC;YACH,IAAI,cAAc,GAEiB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACjE,IAAI,SAAS,GAAsC,MAAM,CAAC;YAE1D,QAAQ,IAAI,EAAE,CAAC;gBACb,KAAK,OAAO;oBACV,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAc,CAAC,CAAC;oBACnC,SAAS,GAAG,MAAM,CAAC;oBACnB,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBAClD,MAAM;gBACR,KAAK,MAAM;oBACT,IAAI,IAAI,EAAE,CAAC;wBACT,IAAK,IAA8B,CAAC,OAAO;4BACzC,OAAQ,IAA8B,CAAC,SAAS,CAAC,CAAC;wBACpD,IAAK,IAA6B,CAAC,MAAM;4BACvC,OAAQ,IAA6B,CAAC,QAAQ,CAAC,CAAC;oBACpD,CAAC;oBACD,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;oBACrC,SAAS,GAAG,OAAO,CAAC;oBACpB,MAAM;gBACR,KAAK,IAAI;oBACP,SAAS,GAAG,KAAK,CAAC;oBAClB,MAAM;gBACR,KAAK,MAAM;oBACT,SAAS,GAAG,MAAM,CAAC;oBACnB,MAAM;gBACR;oBACE,OAAO,CAAC,GAAG,CAAC,oBAAoB,IAAI,iBAAiB,CAAC,CAAC;YAC3D,CAAC;YACD,SAAS,GAAG,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC;gBAClC,CAAC,CAAC,SAAS;gBACX,CAAC,CAAC,GAAG,SAAS,GAAG,SAAS,EAAE,CAAC;YAC/B,MAAM,cAAc,CAAC,SAAS,EAAE,IAAuB,CAAC,CAAC;QAC3D,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CACb,mCAAmC,SAAS,yBAAyB,IAAI,CAAC,QAAQ,MAAM,CAAC,EAAE,CAC5F,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,UAAU,CACd,SAAiB,EACjB,IAA8B,EAC9B,OAAoB,MAAM,EAC1B,IAAI,GAAG,KAAK;QAEZ,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IAClD,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,YAAY,CAAC,SAAiB,EAAE,IAAY,EAAE,IAAI,GAAG,KAAK;QAC9D,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,WAAW,CAAC,SAAiB,EAAE,QAA2B;QAC9D,IAAI,CAAC,IAAI,GAAG,MAAM,qBAAqB,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QACtE,IAAI,GAAW,CAAC;QAChB,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,MAAM,eAAe,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YACpE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC1B,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,EAAE,CAAC,CAAC;QAC/D,CAAC;QAED,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,WAAW,CAAC,SAAiB,EAAE,MAAW;QAC9C,IAAI,CAAC,IAAI,GAAG,MAAM,qBAAqB,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QACtE,MAAM,EAAE,iBAAiB,EAAE,GAAG,MAAM,eAAe,CACjD,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CACxB,CAAC;QAEF,MAAM,KAAK,GAAG,GAAG,CAAC,CAAC,IAAI;QACvB,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,IAAI;QACxB,MAAM,gBAAgB,GAAG,OAAO,CAAC,CAAC,2DAA2D;QAC7F,MAAM,iBAAiB,GAAG,IAAI,iBAAiB,CAAC;YAC9C,KAAK;YACL,MAAM;YACN,gBAAgB;SACjB,CAAC,CAAC;QAEH,MAAM,KAAK,GAAG,MAAM,iBAAiB,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QAC7D,OAAO,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IAClD,CAAC;IACD;;;;;;OAMG;IACH,KAAK,CAAC,WAAW,CAAC,SAAiB,EAAE,MAAc;QACjD,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACjD,CAAC;CACF","sourcesContent":["import path from \"path\";\nimport fs from \"fs\";\nimport { installIfNotAvailable } from \"../utils/fs\";\nimport { SimpleDependencyMap } from \"../utils/types\";\nimport { MdTableDefinition } from \"../utils/md\";\n\n/**\n * @interface AddAttachParams\n * @description Parameters for adding an attachment to a report\n * @summary Interface for attachment parameters\n * @memberOf module:utils\n */\nexport interface AddAttachParams {\n  attach: string | Buffer;\n  description: string | object;\n  context?: any;\n  bufferFormat?: string;\n}\n\n/**\n * @interface AddMsgParams\n * @description Parameters for adding a message to a report\n * @summary Interface for message parameters\n * @memberOf module:utils\n */\nexport interface AddMsgParams {\n  message: string | object;\n  context?: any;\n}\n\n/**\n * @typedef {(\"json\"|\"image\"|\"text\"|\"md\")} PayloadType\n * @description Types of payloads that can be handled\n * @summary Union type for payload types\n * @memberOf module:utils\n */\nexport type PayloadType = \"json\" | \"image\" | \"text\" | \"md\";\n\n/**\n * @description Environment variable key for Jest HTML reporters temporary directory path\n * @summary Constant defining the environment variable key for Jest HTML reporters\n * @const JestReportersTempPathEnvKey\n * @memberOf module:utils\n */\nexport const JestReportersTempPathEnvKey = \"JEST_HTML_REPORTERS_TEMP_DIR_PATH\";\n\n/**\n * @description Array of dependencies required by the test reporter\n * @summary List of npm packages needed for reporting functionality\n * @const dependencies\n * @memberOf module:utils\n */\nconst dependencies = [\"jest-html-reporters\", \"json2md\", \"chartjs-node-canvas\"];\n\n/**\n * @description Normalizes imports to handle both CommonJS and ESModule formats\n * @summary Utility function to handle module import differences between formats\n * @template T - Type of the imported module\n * @param {Promise<T>} importPromise - Promise returned by dynamic import\n * @return {Promise<T>} Normalized module\n * @function normalizeImport\n * @memberOf module:utils\n */\nasync function normalizeImport<T>(importPromise: Promise<T>): Promise<T> {\n  // CommonJS's `module.exports` is wrapped as `default` in ESModule.\n  return importPromise.then((m: any) => (m.default || m) as T);\n}\n\n/**\n * @description Test reporting utility class for managing test results and evidence\n * @summary A comprehensive test reporter that handles various types of test artifacts including messages,\n * attachments, data, images, tables, and graphs. It provides methods to report and store test evidence\n * in different formats and manages dependencies for reporting functionality.\n *\n * @template T - Type of data being reported\n * @param {string} [testCase=\"tests\"] - Name of the test case\n * @param {string} [basePath] - Base path for storing test reports\n * @class\n *\n * @example\n * ```typescript\n * const reporter = new TestReporter('login-test');\n *\n * // Report test messages\n * await reporter.reportMessage('Test Started', 'Login flow initiated');\n *\n * // Report test data\n * await reporter.reportData('user-credentials', { username: 'test' }, 'json');\n *\n * // Report test results table\n * await reporter.reportTable('test-results', {\n *   headers: ['Step', 'Status'],\n *   rows: [\n *     { Step: 'Login', Status: 'Pass' },\n *     { Step: 'Validation', Status: 'Pass' }\n *   ]\n * });\n *\n * // Report test evidence\n * await reporter.reportAttachment('Screenshot', screenshotBuffer);\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant TestReporter\n *   participant FileSystem\n *   participant Dependencies\n *\n *   Client->>TestReporter: new TestReporter(testCase, basePath)\n *   TestReporter->>FileSystem: Create report directory\n *\n *   alt Report Message\n *     Client->>TestReporter: reportMessage(title, message)\n *     TestReporter->>Dependencies: Import helpers\n *     TestReporter->>FileSystem: Store message\n *   else Report Data\n *     Client->>TestReporter: reportData(reference, data, type)\n *     TestReporter->>Dependencies: Process data\n *     TestReporter->>FileSystem: Store formatted data\n *   else Report Table\n *     Client->>TestReporter: reportTable(reference, tableDef)\n *     TestReporter->>Dependencies: Convert to MD format\n *     TestReporter->>FileSystem: Store table\n *   end\n */\nexport class TestReporter {\n  /**\n   * @description Function for adding messages to the test report\n   * @summary Static handler for processing and storing test messages\n   * @type {function(AddMsgParams): Promise<void>}\n   */\n  protected static addMsgFunction: (params: AddMsgParams) => Promise<void>;\n\n  /**\n   * @description Function for adding attachments to the test report\n   * @summary Static handler for processing and storing test attachments\n   * @type {function(AddAttachParams): Promise<void>}\n   */\n  protected static addAttachFunction: (\n    params: AddAttachParams\n  ) => Promise<void>;\n\n  /**\n   * @description Map of dependencies required by the reporter\n   * @summary Stores the current state of dependencies\n   * @type {SimpleDependencyMap}\n   */\n  private deps?: SimpleDependencyMap;\n\n  constructor(\n    protected testCase: string = \"tests\",\n    protected basePath = path.join(\n      process.cwd(),\n      \"workdocs\",\n      \"reports\",\n      \"evidences\"\n    )\n  ) {\n    this.basePath = path.join(basePath, this.testCase);\n    if (!fs.existsSync(this.basePath)) {\n      fs.mkdirSync(basePath, { recursive: true });\n    }\n  }\n\n  /**\n   * @description Imports required helper functions\n   * @summary Ensures all necessary dependencies are available and imports helper functions\n   * @return {Promise<void>} Promise that resolves when helpers are imported\n   */\n  private async importHelpers(): Promise<void> {\n    this.ensureJestHtmlReportersTempDirs();\n    this.deps = await installIfNotAvailable([dependencies[0]], this.deps);\n    // if (!process.env[JestReportersTempPathEnvKey])\n    //   process.env[JestReportersTempPathEnvKey] = './workdocs/reports';\n    const helper = await normalizeImport(import(`${dependencies[0]}/helper`));\n    const { addMsg, addAttach } = helper as {\n      addMsg: typeof TestReporter.addMsgFunction;\n      addAttach: typeof TestReporter.addAttachFunction;\n      tempDirPath?: string;\n      dataDirPath?: string;\n      attachDirPath?: string;\n    };\n    this.overrideJestHtmlReportersTempPaths(helper as Record<string, unknown>);\n    TestReporter.addMsgFunction = addMsg;\n    TestReporter.addAttachFunction = addAttach;\n  }\n\n  private getJestHtmlReportersTempDir(): string {\n    return (\n      process.env[JestReportersTempPathEnvKey] ||\n      path.join(this.basePath, \"jest-html-reporters-temp\")\n    );\n  }\n\n  private ensureJestHtmlReportersTempDirs() {\n    const tempDir = this.getJestHtmlReportersTempDir();\n    fs.mkdirSync(path.join(tempDir, \"data\"), { recursive: true });\n    fs.mkdirSync(path.join(tempDir, \"images\"), { recursive: true });\n  }\n\n  private overrideJestHtmlReportersTempPaths(helper: Record<string, unknown>) {\n    const tempDir = this.getJestHtmlReportersTempDir();\n    helper.tempDirPath = tempDir;\n    helper.dataDirPath = path.join(tempDir, \"data\");\n    helper.attachDirPath = path.join(tempDir, \"images\");\n  }\n\n  /**\n   * @description Reports a message to the test report\n   * @summary Adds a formatted message to the test report with an optional title\n   * @param {string} title - Title of the message\n   * @param {string | object} message - Content of the message\n   * @return {Promise<void>} Promise that resolves when the message is reported\n   */\n  async reportMessage(title: string, message: string | object): Promise<void> {\n    if (!TestReporter.addMsgFunction) await this.importHelpers();\n    const msg = `${title}${message ? `\\n${message}` : \"\"}`;\n    await TestReporter.addMsgFunction({ message: msg });\n  }\n\n  /**\n   * @description Reports an attachment to the test report\n   * @summary Adds a formatted message to the test report with an optional title\n   * @param {string} title - Title of the message\n   * @param {string | Buffer} attachment - Content of the message\n   * @return {Promise<void>} Promise that resolves when the message is reported\n   */\n  async reportAttachment(\n    title: string,\n    attachment: string | Buffer\n  ): Promise<void> {\n    if (!TestReporter.addAttachFunction) await this.importHelpers();\n    await TestReporter.addAttachFunction({\n      attach: attachment,\n      description: title,\n    });\n  }\n\n  /**\n   * @description Reports data with specified type\n   * @summary Processes and stores data in the test report with formatting\n   * @param {string} reference - Reference identifier for the data\n   * @param {string | number | object} data - Data to be reported\n   * @param {PayloadType} type - Type of the payload\n   * @param {boolean} [trim=false] - Whether to trim the data\n   * @return {Promise<void>} Promise that resolves when data is reported\n   */\n  protected async report(\n    reference: string,\n    data: string | number | object | Buffer,\n    type: PayloadType,\n    trim: boolean = false\n  ) {\n    try {\n      let attachFunction:\n        | typeof this.reportMessage\n        | typeof this.reportAttachment = this.reportMessage.bind(this);\n      let extension: \".png\" | \".txt\" | \".md\" | \".json\" = \".txt\";\n\n      switch (type) {\n        case \"image\":\n          data = Buffer.from(data as Buffer);\n          extension = \".png\";\n          attachFunction = this.reportAttachment.bind(this);\n          break;\n        case \"json\":\n          if (trim) {\n            if ((data as { request?: unknown }).request)\n              delete (data as { request?: unknown })[\"request\"];\n            if ((data as { config?: unknown }).config)\n              delete (data as { config?: unknown })[\"config\"];\n          }\n          data = JSON.stringify(data, null, 2);\n          extension = \".json\";\n          break;\n        case \"md\":\n          extension = \".md\";\n          break;\n        case \"text\":\n          extension = \".txt\";\n          break;\n        default:\n          console.log(`Unsupported type ${type}. assuming text`);\n      }\n      reference = reference.includes(\"\\n\")\n        ? reference\n        : `${reference}${extension}`;\n      await attachFunction(reference, data as Buffer | string);\n    } catch (e: unknown) {\n      throw new Error(\n        `Could not store attach artifact ${reference} under to test report ${this.testCase} - ${e}`\n      );\n    }\n  }\n\n  /**\n   * @description Reports data with a specified type\n   * @summary Wrapper method for reporting various types of data\n   * @param {string} reference - Reference identifier for the data\n   * @param {string | number | object} data - Data to be reported\n   * @param {PayloadType} [type=\"json\"] - Type of the payload\n   * @param {boolean} [trim=false] - Whether to trim the data\n   * @return {Promise<void>} Promise that resolves when data is reported\n   */\n  async reportData(\n    reference: string,\n    data: string | number | object,\n    type: PayloadType = \"json\",\n    trim = false\n  ) {\n    return this.report(reference, data, type, trim);\n  }\n\n  /**\n   * @description Reports a JSON object\n   * @summary Convenience method for reporting JSON objects\n   * @param {string} reference - Reference identifier for the object\n   * @param {object} json - JSON object to be reported\n   * @param {boolean} [trim=false] - Whether to trim the object\n   * @return {Promise<void>} Promise that resolves when object is reported\n   */\n  async reportObject(reference: string, json: object, trim = false) {\n    return this.report(reference, json, \"json\", trim);\n  }\n\n  /**\n   * @description Reports a table in markdown format\n   * @summary Converts and stores a table definition in markdown format\n   * @param {string} reference - Reference identifier for the table\n   * @param {MdTableDefinition} tableDef - Table definition object\n   * @return {Promise<void>} Promise that resolves when table is reported\n   */\n  async reportTable(reference: string, tableDef: MdTableDefinition) {\n    this.deps = await installIfNotAvailable([dependencies[1]], this.deps);\n    let txt: string;\n    try {\n      const json2md = await normalizeImport(import(`${dependencies[1]}`));\n      txt = json2md(tableDef);\n    } catch (e: unknown) {\n      throw new Error(`Could not convert JSON to Markdown - ${e}`);\n    }\n\n    return this.report(reference, txt, \"md\");\n  }\n\n  /**\n   * @description Reports a graph using Chart.js\n   * @summary Generates and stores a graph visualization\n   * @param {string} reference - Reference identifier for the graph\n   * @param {any} config - Chart.js configuration object\n   * @return {Promise<void>} Promise that resolves when graph is reported\n   */\n  async reportGraph(reference: string, config: any) {\n    this.deps = await installIfNotAvailable([dependencies[2]], this.deps);\n    const { ChartJSNodeCanvas } = await normalizeImport(\n      import(dependencies[2])\n    );\n\n    const width = 600; //px\n    const height = 800; //px\n    const backgroundColour = \"white\"; // Uses https://www.w3schools.com/tags/canvas_fillstyle.asp\n    const chartJSNodeCanvas = new ChartJSNodeCanvas({\n      width,\n      height,\n      backgroundColour,\n    });\n\n    const image = await chartJSNodeCanvas.renderToBuffer(config);\n    return await this.reportImage(reference, image);\n  }\n  /**\n   * @description Reports an image to the test report\n   * @summary Stores an image buffer in the test report\n   * @param {string} reference - Reference identifier for the image\n   * @param {Buffer} buffer - Image data buffer\n   * @return {Promise<void>} Promise that resolves when image is reported\n   */\n  async reportImage(reference: string, buffer: Buffer) {\n    return this.report(reference, buffer, \"image\");\n  }\n}\n"]}

package/lib/esm/tests/index.d.ts

@@ -1,2 +1,4 @@
-export * from "./TestReporter";
 export * from "./Consumer";
+export * from "./TestReporter";
+export * from "./utils";
+export * from "./jestPerformanceRunner";

package/lib/esm/tests/index.js

@@ -1,3 +1,5 @@
-export * from "./TestReporter.js";
 export * from "./Consumer.js";
-//# sourceMappingURL=index.js.map
+export * from "./TestReporter.js";
+export * from "./utils.js";
+export * from "./jestPerformanceRunner.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGVzdHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsOEJBQTJCO0FBQzNCLGtDQUErQjtBQUMvQiwyQkFBd0I7QUFDeEIsMkNBQXdDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vQ29uc3VtZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1Rlc3RSZXBvcnRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2plc3RQZXJmb3JtYW5jZVJ1bm5lclwiO1xuIl19

package/lib/esm/tests/jestPerformanceRunner.d.ts

@@ -0,0 +1,7 @@
+import { PerformanceScenario, PerformanceRunner } from "../utils/performanceRunner";
+export type JestPerformanceScenario<TContext = Record<string, unknown>> = PerformanceScenario<TContext>;
+export declare class JestPerformanceRunner<TContext = Record<string, unknown>> extends PerformanceRunner<TContext> {
+    protected scenario: JestPerformanceScenario<TContext>;
+    constructor(scenario: JestPerformanceScenario<TContext>);
+    describeSuite(): void;
+}

package/lib/esm/tests/jestPerformanceRunner.js

@@ -0,0 +1,15 @@
+import { PerformanceRunner } from "./../utils/performanceRunner.js";
+export class JestPerformanceRunner extends PerformanceRunner {
+    constructor(scenario) {
+        super(scenario);
+        this.scenario = scenario;
+    }
+    describeSuite() {
+        describe(this.scenario.name, () => {
+            it("executes the performance scenario", async () => {
+                await this.run();
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamVzdFBlcmZvcm1hbmNlUnVubmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Rlc3RzL2plc3RQZXJmb3JtYW5jZVJ1bm5lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQXVCLGlCQUFpQixFQUFFLHdDQUFtQztBQUtwRixNQUFNLE9BQU8scUJBRVgsU0FBUSxpQkFBMkI7SUFHbkMsWUFBWSxRQUEyQztRQUNyRCxLQUFLLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDaEIsSUFBSSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7SUFDM0IsQ0FBQztJQUVNLGFBQWE7UUFDbEIsUUFBUSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLEdBQUcsRUFBRTtZQUNoQyxFQUFFLENBQUMsbUNBQW1DLEVBQUUsS0FBSyxJQUFJLEVBQUU7Z0JBQ2pELE1BQU0sSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1lBQ25CLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQZXJmb3JtYW5jZVNjZW5hcmlvLCBQZXJmb3JtYW5jZVJ1bm5lciB9IGZyb20gXCIuLi91dGlscy9wZXJmb3JtYW5jZVJ1bm5lclwiO1xuXG5leHBvcnQgdHlwZSBKZXN0UGVyZm9ybWFuY2VTY2VuYXJpbzxUQ29udGV4dCA9IFJlY29yZDxzdHJpbmcsIHVua25vd24+PiA9XG4gIFBlcmZvcm1hbmNlU2NlbmFyaW88VENvbnRleHQ+O1xuXG5leHBvcnQgY2xhc3MgSmVzdFBlcmZvcm1hbmNlUnVubmVyPFxuICBUQ29udGV4dCA9IFJlY29yZDxzdHJpbmcsIHVua25vd24+LFxuPiBleHRlbmRzIFBlcmZvcm1hbmNlUnVubmVyPFRDb250ZXh0PiB7XG4gIHByb3RlY3RlZCBvdmVycmlkZSBzY2VuYXJpbzogSmVzdFBlcmZvcm1hbmNlU2NlbmFyaW88VENvbnRleHQ+O1xuXG4gIGNvbnN0cnVjdG9yKHNjZW5hcmlvOiBKZXN0UGVyZm9ybWFuY2VTY2VuYXJpbzxUQ29udGV4dD4pIHtcbiAgICBzdXBlcihzY2VuYXJpbyk7XG4gICAgdGhpcy5zY2VuYXJpbyA9IHNjZW5hcmlvO1xuICB9XG5cbiAgcHVibGljIGRlc2NyaWJlU3VpdGUoKTogdm9pZCB7XG4gICAgZGVzY3JpYmUodGhpcy5zY2VuYXJpby5uYW1lLCAoKSA9PiB7XG4gICAgICBpdChcImV4ZWN1dGVzIHRoZSBwZXJmb3JtYW5jZSBzY2VuYXJpb1wiLCBhc3luYyAoKSA9PiB7XG4gICAgICAgIGF3YWl0IHRoaXMucnVuKCk7XG4gICAgICB9KTtcbiAgICB9KTtcbiAgfVxufVxuIl19

package/lib/esm/tests/utils.d.ts

@@ -0,0 +1,5 @@
+import { SpawnOptionsWithoutStdio } from "child_process";
+import { OutputWriterConstructor, StandardOutputWriter } from "../writers";
+import { CommandResult } from "../utils/types";
+import { TestReporter } from "./TestReporter";
+export declare function runAndReport<R = string>(command: string, opts: SpawnOptionsWithoutStdio | undefined, outputConstructor: OutputWriterConstructor<R, StandardOutputWriter<R>, Error> | undefined, reporter: TestReporter, commandPrefix?: string, ...args: unknown[]): CommandResult<R>;

package/lib/esm/tests/utils.js

@@ -0,0 +1,33 @@
+import { StandardOutputWriter } from "./../writers/index.js";
+import { runCommand } from "./../utils/utils.js";
+import { sf } from "@decaf-ts/logging";
+import { style } from "styled-string-builder";
+export function runAndReport(command, opts = {}, outputConstructor = (StandardOutputWriter), reporter, commandPrefix = "{cwd} $ ", ...args) {
+    try {
+        const cmd = runCommand(command, opts, outputConstructor, ...args);
+        const p = cmd.promise;
+        const resolution = async (resolve, result) => {
+            await reporter.reportData(`${expect.getState().currentTestName || "no test name"} - ${command}`, `${sf(commandPrefix, { cwd: opts.cwd || process.cwd() })}${command}\n${style("SUCCESS").green.bold}\n${result}`, "text", true);
+            resolve(result);
+        };
+        const rejection = async (reject, error) => {
+            try {
+                await reporter.reportData(`${expect.getState().currentTestName || "no test name"} - ${command}`, `${sf(commandPrefix, { cwd: opts.cwd || process.cwd() })}${command}\n${style("FAIL").red.bold}\n${error}`, "text", true);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            reject(error);
+        };
+        cmd.promise = new Promise((resolve, reject) => {
+            return p
+                .then(async (r) => await resolution(resolve, r))
+                .catch(async (e) => await rejection(reject, e));
+        });
+        return cmd;
+    }
+    catch (e) {
+        throw new Error(`Unable to create reportable command runner for ${commandPrefix}: ${e}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/utils/constants.js

@@ -65,4 +65,4 @@ export var Tokens;
  * @memberOf module:utils
  */
 export const AbortCode = "Aborted";
-//# sourceMappingURL=constants.js.map
+//# sourceMappingURL=data:application/json;base64,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