@decaf-ts/utils 0.1.7 → 0.2.1

package/lib/utils/md.d.ts

@@ -0,0 +1,156 @@
+/**
+ * @description Single line markdown element type
+ * @summary Represents the possible header levels in markdown
+ * @typedef {"h1"|"h2"|"h3"|"h4"|"h5"|"h6"} MdSingleLineElement
+ * @memberOf @decaf-ts/utils
+ */
+export type MdSingleLineElement = "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+/**
+ * @description Multi-line element types in markdown
+ * @summary Defines the available multi-line element types
+ * @typedef {"p"|"blockquote"} MdMultiLineElement
+ * @memberOf @decaf-ts/utils
+ */
+export type MdMultiLineElement = "p" | "blockquote";
+/**
+ * @description List element types in markdown
+ * @summary Defines the available list types
+ * @typedef {"ul"|"ol"} MdListElement
+ * @memberOf @decaf-ts/utils
+ */
+export type MdListElement = "ul" | "ol";
+/**
+ * @description List element types in markdown
+ * @summary Defines the available list types
+ * @typedef {Object} MdSingleLine
+ * @property {string} [ul] - unordered list
+ * @property {string} [ol] - ordered list
+ * @memberOf @decaf-ts/utils
+ */
+export type MdSingleLine = {
+    [k in MdSingleLineElement]?: string;
+};
+/**
+ * @description Multi-line markdown element type
+ * @summary Represents markdown elements that can contain multiple lines of text
+ * @typedef {Object} MdMultiLine
+ * @property {string|string[]} [p] - Paragraph content
+ * @property {string|string[]} [blockquote] - Blockquote content
+ * @memberOf @decaf-ts/utils
+ */
+export type MdMultiLine = {
+    [k in MdMultiLineElement]?: string | string[];
+};
+/**
+ * @description Image definition type in markdown
+ * @summary Defines the structure for image elements
+ * @typedef {Object} MdImageDefinition
+ * @property {string} [title] - Optional image title
+ * @property {string} source - Image source URL
+ * @property {string} [alt] - Optional alternative text
+ * @memberOf @decaf-ts/utils
+ */
+export type MdImageDefinition = {
+    title?: string;
+    source: string;
+    alt?: string;
+};
+/**
+ * @description Image element type in markdown
+ * @summary Represents an image element with its properties
+ * @typedef {Object} MdImage
+ * @property {MdImageDefinition} img - The image definition object
+ * @memberOf @decaf-ts/utils
+ */
+export type MdImage = {
+    img: MdImageDefinition;
+};
+/**
+ * @description List item element type in markdown
+ * @summary Represents ordered and unordered lists in markdown
+ * @typedef {Object} MdListItem
+ * @property {string[]} ul - Unordered list items
+ * @property {string[]} ol - Ordered list items
+ * @memberOf @decaf-ts/utils
+ */
+export type MdListItem = {
+    [k in MdListElement]: string[];
+};
+/**
+ * @description Table definition type in markdown
+ * @summary Defines the structure for table elements
+ * @typedef {Object} MdTableDefinition
+ * @property {string[]} headers - Array of table header names
+ * @property {Object[]} rows - Array of row objects containing column values
+ * @memberOf @decaf-ts/utils
+ */
+export type MdTableDefinition = {
+    headers: string[];
+    rows: {
+        [column: string]: string | string[];
+    }[];
+};
+/**
+ * @description Table element type in markdown
+ * @summary Represents a table structure with headers and rows
+ * @typedef {Object} MdTable
+ * @property {MdTableDefinition} table - The table definition object
+ * @memberOf @decaf-ts/utils
+ */
+export type MdTable = {
+    table: MdTableDefinition;
+};
+/**
+ * @description Code block definition type in markdown
+ * @summary Defines the structure for code blocks
+ * @typedef {Object} MdCodeDefinition
+ * @property {string} [language] - Optional programming language specification
+ * @property {string|string[]} content - The code content as string or array of strings
+ * @memberOf @decaf-ts/utils
+ */
+export type MdCodeDefinition = {
+    language?: string;
+    content: string | string[];
+};
+/**
+ * @description Code block element type in markdown
+ * @summary Represents a code block with optional language specification
+ * @typedef {Object} MdCode
+ * @property {MdCodeDefinition} code - The code block definition object
+ * @memberOf @decaf-ts/utils
+ */
+export type MdCode = {
+    code: MdCodeDefinition;
+};
+/**
+ * @description Horizontal rule element type in markdown
+ * @summary Represents a horizontal rule separator
+ * @typedef {Object} MdSeparator
+ * @property {string} hr - The horizontal rule representation
+ * @memberOf @decaf-ts/utils
+ */
+export type MdSeparator = {
+    hr: string;
+};
+/**
+ * @description Link element type in markdown
+ * @summary Represents a hyperlink with title and source
+ * @typedef {Object} MdLink
+ * @property {{title: string, source: string}} link - The link definition object
+ * @memberOf @decaf-ts/utils
+ */
+export type MdLink = {
+    link: {
+        title: string;
+        source: string;
+    };
+};
+/**
+ * @description Markdown element type definition
+ * @summary Represents all possible markdown elements that can be used in document generation.
+ * This type combines various markdown elements including headers, paragraphs, images, lists,
+ * tables, code blocks, separators, and links into a union type for flexible markdown content creation.
+ * @typedef {(MdSingleLine | MdMultiLine | MdImage | MdListItem | MdTable | MdCode | MdSeparator | MdLink)} MdElements
+ * @memberOf @decaf-ts/utils
+ */
+export type MdElements = MdSingleLine | MdMultiLine | MdImage | MdListItem | MdTable | MdCode | MdSeparator | MdLink;

package/lib/utils/tests.cjs

@@ -259,5 +259,4 @@ class TestReporter {
     }
 }
 exports.TestReporter = TestReporter;
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/utils/tests.ts"],"names":[],"mappings":"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","file":"utils/tests.js","sourcesContent":["import path from \"path\";\nimport fs from \"fs\";\nimport { MdTableDefinition } from \"./md\";\nimport { installIfNotAvailable } from \"./fs\";\nimport { SimpleDependencyMap } from \"./types\";\n\n/**\n * @interface AddAttachParams\n * @description Parameters for adding an attachment to a report\n * @summary Interface for attachment parameters\n * @memberOf module:@decaf-ts/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:@decaf-ts/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:@decaf-ts/utils\n */\nexport type PayloadType = \"json\" | \"image\" | \"text\" | \"md\";\n\nexport const JestReportersTempPathEnvKey = \"JEST_HTML_REPORTERS_TEMP_DIR_PATH\";\n\nconst dependencies = [\"jest-html-reporters\", \"json2md\", \"chartjs-node-canvas\"];\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.deps = await installIfNotAvailable([dependencies[0]], this.deps);\n    // if (!process.env[JestReportersTempPathEnvKey])\n    //   process.env[JestReportersTempPathEnvKey] = './workdocs/reports';\n    const { addMsg, addAttach } = await normalizeImport(\n      import(`${dependencies[0]}/helper`)\n    );\n    TestReporter.addMsgFunction = addMsg;\n    TestReporter.addAttachFunction = addAttach;\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  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  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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tests.js","sourceRoot":"","sources":["../../src/utils/tests.ts"],"names":[],"mappings":"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","sourcesContent":["import path from \"path\";\nimport fs from \"fs\";\nimport { MdTableDefinition } from \"./md\";\nimport { installIfNotAvailable } from \"./fs\";\nimport { SimpleDependencyMap } from \"./types\";\n\n/**\n * @interface AddAttachParams\n * @description Parameters for adding an attachment to a report\n * @summary Interface for attachment parameters\n * @memberOf module:@decaf-ts/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:@decaf-ts/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:@decaf-ts/utils\n */\nexport type PayloadType = \"json\" | \"image\" | \"text\" | \"md\";\n\nexport const JestReportersTempPathEnvKey = \"JEST_HTML_REPORTERS_TEMP_DIR_PATH\";\n\nconst dependencies = [\"jest-html-reporters\", \"json2md\", \"chartjs-node-canvas\"];\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.deps = await installIfNotAvailable([dependencies[0]], this.deps);\n    // if (!process.env[JestReportersTempPathEnvKey])\n    //   process.env[JestReportersTempPathEnvKey] = './workdocs/reports';\n    const { addMsg, addAttach } = await normalizeImport(\n      import(`${dependencies[0]}/helper`)\n    );\n    TestReporter.addMsgFunction = addMsg;\n    TestReporter.addAttachFunction = addAttach;\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  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  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/utils/tests.d.ts

@@ -0,0 +1,170 @@
+import { MdTableDefinition } from "./md";
+/**
+ * @interface AddAttachParams
+ * @description Parameters for adding an attachment to a report
+ * @summary Interface for attachment parameters
+ * @memberOf module:@decaf-ts/utils
+ */
+export interface AddAttachParams {
+    attach: string | Buffer;
+    description: string | object;
+    context?: any;
+    bufferFormat?: string;
+}
+/**
+ * @interface AddMsgParams
+ * @description Parameters for adding a message to a report
+ * @summary Interface for message parameters
+ * @memberOf module:@decaf-ts/utils
+ */
+export interface AddMsgParams {
+    message: string | object;
+    context?: any;
+}
+/**
+ * @typedef {("json"|"image"|"text"|"md")} PayloadType
+ * @description Types of payloads that can be handled
+ * @summary Union type for payload types
+ * @memberOf module:@decaf-ts/utils
+ */
+export type PayloadType = "json" | "image" | "text" | "md";
+export declare const JestReportersTempPathEnvKey = "JEST_HTML_REPORTERS_TEMP_DIR_PATH";
+/**
+ * @description Test reporting utility class for managing test results and evidence
+ * @summary A comprehensive test reporter that handles various types of test artifacts including messages,
+ * attachments, data, images, tables, and graphs. It provides methods to report and store test evidence
+ * in different formats and manages dependencies for reporting functionality.
+ *
+ * @template T - Type of data being reported
+ * @param {string} [testCase="tests"] - Name of the test case
+ * @param {string} [basePath] - Base path for storing test reports
+ * @class
+ *
+ * @example
+ * ```typescript
+ * const reporter = new TestReporter('login-test');
+ *
+ * // Report test messages
+ * await reporter.reportMessage('Test Started', 'Login flow initiated');
+ *
+ * // Report test data
+ * await reporter.reportData('user-credentials', { username: 'test' }, 'json');
+ *
+ * // Report test results table
+ * await reporter.reportTable('test-results', {
+ *   headers: ['Step', 'Status'],
+ *   rows: [
+ *     { Step: 'Login', Status: 'Pass' },
+ *     { Step: 'Validation', Status: 'Pass' }
+ *   ]
+ * });
+ *
+ * // Report test evidence
+ * await reporter.reportAttachment('Screenshot', screenshotBuffer);
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant TestReporter
+ *   participant FileSystem
+ *   participant Dependencies
+ *
+ *   Client->>TestReporter: new TestReporter(testCase, basePath)
+ *   TestReporter->>FileSystem: Create report directory
+ *
+ *   alt Report Message
+ *     Client->>TestReporter: reportMessage(title, message)
+ *     TestReporter->>Dependencies: Import helpers
+ *     TestReporter->>FileSystem: Store message
+ *   else Report Data
+ *     Client->>TestReporter: reportData(reference, data, type)
+ *     TestReporter->>Dependencies: Process data
+ *     TestReporter->>FileSystem: Store formatted data
+ *   else Report Table
+ *     Client->>TestReporter: reportTable(reference, tableDef)
+ *     TestReporter->>Dependencies: Convert to MD format
+ *     TestReporter->>FileSystem: Store table
+ *   end
+ */
+export declare class TestReporter {
+    protected testCase: string;
+    protected basePath: string;
+    /**
+     * @description Function for adding messages to the test report
+     * @summary Static handler for processing and storing test messages
+     * @type {function(AddMsgParams): Promise<void>}
+     */
+    protected static addMsgFunction: (params: AddMsgParams) => Promise<void>;
+    /**
+     * @description Function for adding attachments to the test report
+     * @summary Static handler for processing and storing test attachments
+     * @type {function(AddAttachParams): Promise<void>}
+     */
+    protected static addAttachFunction: (params: AddAttachParams) => Promise<void>;
+    /**
+     * @description Map of dependencies required by the reporter
+     * @summary Stores the current state of dependencies
+     * @type {SimpleDependencyMap}
+     */
+    private deps?;
+    constructor(testCase?: string, basePath?: string);
+    /**
+     * @description Imports required helper functions
+     * @summary Ensures all necessary dependencies are available and imports helper functions
+     * @return {Promise<void>} Promise that resolves when helpers are imported
+     */
+    private importHelpers;
+    /**
+     * @description Reports a message to the test report
+     * @summary Adds a formatted message to the test report with an optional title
+     * @param {string} title - Title of the message
+     * @param {string | object} message - Content of the message
+     * @return {Promise<void>} Promise that resolves when the message is reported
+     */
+    reportMessage(title: string, message: string | object): Promise<void>;
+    /**
+     * @description Reports an attachment to the test report
+     * @summary Adds a formatted message to the test report with an optional title
+     * @param {string} title - Title of the message
+     * @param {string | Buffer} attachment - Content of the message
+     * @return {Promise<void>} Promise that resolves when the message is reported
+     */
+    reportAttachment(title: string, attachment: string | Buffer): Promise<void>;
+    /**
+     * @description Reports data with specified type
+     * @summary Processes and stores data in the test report with formatting
+     * @param {string} reference - Reference identifier for the data
+     * @param {string | number | object} data - Data to be reported
+     * @param {PayloadType} type - Type of the payload
+     * @param {boolean} [trim=false] - Whether to trim the data
+     * @return {Promise<void>} Promise that resolves when data is reported
+     */
+    protected report(reference: string, data: string | number | object | Buffer, type: PayloadType, trim?: boolean): Promise<void>;
+    reportData(reference: string, data: string | number | object, type?: PayloadType, trim?: boolean): Promise<void>;
+    reportObject(reference: string, json: object, trim?: boolean): Promise<void>;
+    /**
+     * @description Reports a table in markdown format
+     * @summary Converts and stores a table definition in markdown format
+     * @param {string} reference - Reference identifier for the table
+     * @param {MdTableDefinition} tableDef - Table definition object
+     * @return {Promise<void>} Promise that resolves when table is reported
+     */
+    reportTable(reference: string, tableDef: MdTableDefinition): Promise<void>;
+    /**
+     * @description Reports a graph using Chart.js
+     * @summary Generates and stores a graph visualization
+     * @param {string} reference - Reference identifier for the graph
+     * @param {any} config - Chart.js configuration object
+     * @return {Promise<void>} Promise that resolves when graph is reported
+     */
+    reportGraph(reference: string, config: any): Promise<void>;
+    /**
+     * @description Reports an image to the test report
+     * @summary Stores an image buffer in the test report
+     * @param {string} reference - Reference identifier for the image
+     * @param {Buffer} buffer - Image data buffer
+     * @return {Promise<void>} Promise that resolves when image is reported
+     */
+    reportImage(reference: string, buffer: Buffer): Promise<void>;
+}

package/lib/utils/text.cjs

@@ -149,5 +149,4 @@ function toPascalCase(text) {
 function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/utils/text.ts"],"names":[],"mappings":";;AAeA,wBAQC;AA0BD,8CAQC;AAED,kCAUC;AAcD,kCAMC;AAcD,kCAEC;AAaD,kCAKC;AAaD,kCAKC;AAcD,oCAIC;AAED,oCAEC;AAnKD;;;;;;;;;;;;;;GAcG;AACH,SAAgB,MAAM,CACpB,GAAW,EACX,MAAc,EACd,OAAe,GAAG;IAElB,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;IACxE,OAAO,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAClC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,SAAgB,iBAAiB,CAC/B,KAAa,EACb,MAAuC;IAEvC,OAAO,KAAK,CAAC,OAAO,CAClB,wBAAwB,EACxB,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,CAAE,MAAM,CAAC,QAAkB,CAAY,IAAI,KAAK,CACrE,CAAC;AACJ,CAAC;AAED,SAAgB,WAAW,CACzB,KAAa,EACb,MAAuC,EACvC,QAAgB,GAAG;IAEnB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE;QAC5C,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;QACpD,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,GAAa,CAAC,CAAC;IAC/C,CAAC,CAAC,CAAC;IACH,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,WAAW,CAAC,IAAY;IACtC,OAAO,IAAI;SACR,OAAO,CAAC,qBAAqB,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAC9C,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CACtD;SACA,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AACzB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,WAAW,CAAC,IAAY;IACtC,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;AACzC,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,WAAW,CAAC,IAAY;IACtC,OAAO,IAAI;SACR,OAAO,CAAC,iBAAiB,EAAE,OAAO,CAAC;SACnC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC;SACvB,WAAW,EAAE,CAAC;AACnB,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,WAAW,CAAC,IAAY;IACtC,OAAO,IAAI;SACR,OAAO,CAAC,iBAAiB,EAAE,OAAO,CAAC;SACnC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC;SACvB,WAAW,EAAE,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,YAAY,CAAC,IAAY;IACvC,OAAO,IAAI;SACR,OAAO,CAAC,qBAAqB,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;SAC5D,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AACzB,CAAC;AAED,SAAgB,YAAY,CAAC,MAAc;IACzC,OAAO,MAAM,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC,CAAC,oCAAoC;AAC5F,CAAC","file":"utils/text.js","sourcesContent":["/**\n * @description Pads the end of a string with a specified character.\n * @summary Extends the input string to a specified length by adding a padding character to the end.\n * If the input string is already longer than the specified length, it is returned unchanged.\n *\n * @param {string} str - The input string to be padded.\n * @param {number} length - The desired total length of the resulting string.\n * @param {string} [char=\" \"] - The character to use for padding. Defaults to a space.\n * @return {string} The padded string.\n * @throws {Error} If the padding character is not exactly one character long.\n *\n * @function padEnd\n *\n * @memberOf module:TextUtils\n */\nexport function padEnd(\n  str: string,\n  length: number,\n  char: string = \" \"\n): string {\n  if (char.length !== 1)\n    throw new Error(\"Invalid character length for padding. must be one!\");\n  return str.padEnd(length, char);\n}\n\n/**\n * @description Replaces placeholders in a string with provided values.\n * @summary Interpolates a string by replacing placeholders of the form ${variableName}\n * with corresponding values from the provided object. If a placeholder doesn't have\n * a corresponding value, it is left unchanged in the string.\n *\n * @param {string} input - The input string containing placeholders to be replaced.\n * @param {Record<string, number | string>} values - An object containing key-value pairs for replacement.\n * @return {string} The interpolated string with placeholders replaced by their corresponding values.\n *\n * @function patchPlaceholders\n *\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant patchString\n *   participant String.replace\n *   Caller->>patchString: Call with input and values\n *   patchString->>String.replace: Call with regex and replacement function\n *   String.replace->>patchString: Return replaced string\n *   patchString-->>Caller: Return patched string\n *\n * @memberOf module:TextUtils\n */\nexport function patchPlaceholders(\n  input: string,\n  values: Record<string, number | string>\n): string {\n  return input.replace(\n    /\\$\\{([a-zA-Z0-9_]+)\\}/g,\n    (match, variable) => (values[variable as string] as string) || match\n  );\n}\n\nexport function patchString(\n  input: string,\n  values: Record<string, number | string>,\n  flags: string = \"g\"\n): string {\n  Object.entries(values).forEach(([key, val]) => {\n    const regexp = new RegExp(escapeRegExp(key), flags);\n    input = input.replace(regexp, val as string);\n  });\n  return input;\n}\n\n/**\n * @description Converts a string to camelCase.\n * @summary Transforms the input string into camelCase format, where words are joined without spaces\n * and each word after the first starts with a capital letter.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to camelCase.\n *\n * @function toCamelCase\n *\n * @memberOf module:TextUtils\n */\nexport function toCamelCase(text: string): string {\n  return text\n    .replace(/(?:^\\w|[A-Z]|\\b\\w)/g, (word, index) =>\n      index === 0 ? word.toLowerCase() : word.toUpperCase()\n    )\n    .replace(/\\s+/g, \"\");\n}\n\n/**\n * @description Converts a string to ENVIRONMENT_VARIABLE format.\n * @summary Transforms the input string into uppercase with words separated by underscores,\n * typically used for environment variable names.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to ENVIRONMENT_VARIABLE format.\n *\n * @function toENVFormat\n *\n * @memberOf module:TextUtils\n */\nexport function toENVFormat(text: string): string {\n  return toSnakeCase(text).toUpperCase();\n}\n\n/**\n * @description Converts a string to snake_case.\n * @summary Transforms the input string into lowercase with words separated by underscores.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to snake_case.\n *\n * @function toSnakeCase\n *\n * @memberOf module:TextUtils\n */\nexport function toSnakeCase(text: string): string {\n  return text\n    .replace(/([a-z])([A-Z])/g, \"$1_$2\")\n    .replace(/[\\s-]+/g, \"_\")\n    .toLowerCase();\n}\n\n/**\n * @description Converts a string to kebab-case.\n * @summary Transforms the input string into lowercase with words separated by hyphens.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to kebab-case.\n *\n * @function toKebabCase\n *\n * @memberOf module:TextUtils\n */\nexport function toKebabCase(text: string): string {\n  return text\n    .replace(/([a-z])([A-Z])/g, \"$1-$2\")\n    .replace(/[\\s_]+/g, \"-\")\n    .toLowerCase();\n}\n\n/**\n * @description Converts a string to PascalCase.\n * @summary Transforms the input string into PascalCase format, where words are joined without spaces\n * and each word starts with a capital letter.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to PascalCase.\n *\n * @function toPascalCase\n *\n * @memberOf module:TextUtils\n */\nexport function toPascalCase(text: string): string {\n  return text\n    .replace(/(?:^\\w|[A-Z]|\\b\\w)/g, (word) => word.toUpperCase())\n    .replace(/\\s+/g, \"\");\n}\n\nexport function escapeRegExp(string: string) {\n  return string.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"); // $& means the whole matched string\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"text.js","sourceRoot":"","sources":["../../src/utils/text.ts"],"names":[],"mappings":";;AAeA,wBAQC;AA0BD,8CAQC;AAED,kCAUC;AAcD,kCAMC;AAcD,kCAEC;AAaD,kCAKC;AAaD,kCAKC;AAcD,oCAIC;AAED,oCAEC;AAnKD;;;;;;;;;;;;;;GAcG;AACH,SAAgB,MAAM,CACpB,GAAW,EACX,MAAc,EACd,OAAe,GAAG;IAElB,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;IACxE,OAAO,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAClC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,SAAgB,iBAAiB,CAC/B,KAAa,EACb,MAAuC;IAEvC,OAAO,KAAK,CAAC,OAAO,CAClB,wBAAwB,EACxB,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,CAAE,MAAM,CAAC,QAAkB,CAAY,IAAI,KAAK,CACrE,CAAC;AACJ,CAAC;AAED,SAAgB,WAAW,CACzB,KAAa,EACb,MAAuC,EACvC,QAAgB,GAAG;IAEnB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE;QAC5C,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;QACpD,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,GAAa,CAAC,CAAC;IAC/C,CAAC,CAAC,CAAC;IACH,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,WAAW,CAAC,IAAY;IACtC,OAAO,IAAI;SACR,OAAO,CAAC,qBAAqB,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAC9C,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CACtD;SACA,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AACzB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,WAAW,CAAC,IAAY;IACtC,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;AACzC,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,WAAW,CAAC,IAAY;IACtC,OAAO,IAAI;SACR,OAAO,CAAC,iBAAiB,EAAE,OAAO,CAAC;SACnC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC;SACvB,WAAW,EAAE,CAAC;AACnB,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,WAAW,CAAC,IAAY;IACtC,OAAO,IAAI;SACR,OAAO,CAAC,iBAAiB,EAAE,OAAO,CAAC;SACnC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC;SACvB,WAAW,EAAE,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,YAAY,CAAC,IAAY;IACvC,OAAO,IAAI;SACR,OAAO,CAAC,qBAAqB,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;SAC5D,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AACzB,CAAC;AAED,SAAgB,YAAY,CAAC,MAAc;IACzC,OAAO,MAAM,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC,CAAC,oCAAoC;AAC5F,CAAC","sourcesContent":["/**\n * @description Pads the end of a string with a specified character.\n * @summary Extends the input string to a specified length by adding a padding character to the end.\n * If the input string is already longer than the specified length, it is returned unchanged.\n *\n * @param {string} str - The input string to be padded.\n * @param {number} length - The desired total length of the resulting string.\n * @param {string} [char=\" \"] - The character to use for padding. Defaults to a space.\n * @return {string} The padded string.\n * @throws {Error} If the padding character is not exactly one character long.\n *\n * @function padEnd\n *\n * @memberOf module:TextUtils\n */\nexport function padEnd(\n  str: string,\n  length: number,\n  char: string = \" \"\n): string {\n  if (char.length !== 1)\n    throw new Error(\"Invalid character length for padding. must be one!\");\n  return str.padEnd(length, char);\n}\n\n/**\n * @description Replaces placeholders in a string with provided values.\n * @summary Interpolates a string by replacing placeholders of the form ${variableName}\n * with corresponding values from the provided object. If a placeholder doesn't have\n * a corresponding value, it is left unchanged in the string.\n *\n * @param {string} input - The input string containing placeholders to be replaced.\n * @param {Record<string, number | string>} values - An object containing key-value pairs for replacement.\n * @return {string} The interpolated string with placeholders replaced by their corresponding values.\n *\n * @function patchPlaceholders\n *\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant patchString\n *   participant String.replace\n *   Caller->>patchString: Call with input and values\n *   patchString->>String.replace: Call with regex and replacement function\n *   String.replace->>patchString: Return replaced string\n *   patchString-->>Caller: Return patched string\n *\n * @memberOf module:TextUtils\n */\nexport function patchPlaceholders(\n  input: string,\n  values: Record<string, number | string>\n): string {\n  return input.replace(\n    /\\$\\{([a-zA-Z0-9_]+)\\}/g,\n    (match, variable) => (values[variable as string] as string) || match\n  );\n}\n\nexport function patchString(\n  input: string,\n  values: Record<string, number | string>,\n  flags: string = \"g\"\n): string {\n  Object.entries(values).forEach(([key, val]) => {\n    const regexp = new RegExp(escapeRegExp(key), flags);\n    input = input.replace(regexp, val as string);\n  });\n  return input;\n}\n\n/**\n * @description Converts a string to camelCase.\n * @summary Transforms the input string into camelCase format, where words are joined without spaces\n * and each word after the first starts with a capital letter.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to camelCase.\n *\n * @function toCamelCase\n *\n * @memberOf module:TextUtils\n */\nexport function toCamelCase(text: string): string {\n  return text\n    .replace(/(?:^\\w|[A-Z]|\\b\\w)/g, (word, index) =>\n      index === 0 ? word.toLowerCase() : word.toUpperCase()\n    )\n    .replace(/\\s+/g, \"\");\n}\n\n/**\n * @description Converts a string to ENVIRONMENT_VARIABLE format.\n * @summary Transforms the input string into uppercase with words separated by underscores,\n * typically used for environment variable names.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to ENVIRONMENT_VARIABLE format.\n *\n * @function toENVFormat\n *\n * @memberOf module:TextUtils\n */\nexport function toENVFormat(text: string): string {\n  return toSnakeCase(text).toUpperCase();\n}\n\n/**\n * @description Converts a string to snake_case.\n * @summary Transforms the input string into lowercase with words separated by underscores.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to snake_case.\n *\n * @function toSnakeCase\n *\n * @memberOf module:TextUtils\n */\nexport function toSnakeCase(text: string): string {\n  return text\n    .replace(/([a-z])([A-Z])/g, \"$1_$2\")\n    .replace(/[\\s-]+/g, \"_\")\n    .toLowerCase();\n}\n\n/**\n * @description Converts a string to kebab-case.\n * @summary Transforms the input string into lowercase with words separated by hyphens.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to kebab-case.\n *\n * @function toKebabCase\n *\n * @memberOf module:TextUtils\n */\nexport function toKebabCase(text: string): string {\n  return text\n    .replace(/([a-z])([A-Z])/g, \"$1-$2\")\n    .replace(/[\\s_]+/g, \"-\")\n    .toLowerCase();\n}\n\n/**\n * @description Converts a string to PascalCase.\n * @summary Transforms the input string into PascalCase format, where words are joined without spaces\n * and each word starts with a capital letter.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to PascalCase.\n *\n * @function toPascalCase\n *\n * @memberOf module:TextUtils\n */\nexport function toPascalCase(text: string): string {\n  return text\n    .replace(/(?:^\\w|[A-Z]|\\b\\w)/g, (word) => word.toUpperCase())\n    .replace(/\\s+/g, \"\");\n}\n\nexport function escapeRegExp(string: string) {\n  return string.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"); // $& means the whole matched string\n}\n"]}

package/lib/utils/text.d.ts

@@ -0,0 +1,106 @@
+/**
+ * @description Pads the end of a string with a specified character.
+ * @summary Extends the input string to a specified length by adding a padding character to the end.
+ * If the input string is already longer than the specified length, it is returned unchanged.
+ *
+ * @param {string} str - The input string to be padded.
+ * @param {number} length - The desired total length of the resulting string.
+ * @param {string} [char=" "] - The character to use for padding. Defaults to a space.
+ * @return {string} The padded string.
+ * @throws {Error} If the padding character is not exactly one character long.
+ *
+ * @function padEnd
+ *
+ * @memberOf module:TextUtils
+ */
+export declare function padEnd(str: string, length: number, char?: string): string;
+/**
+ * @description Replaces placeholders in a string with provided values.
+ * @summary Interpolates a string by replacing placeholders of the form ${variableName}
+ * with corresponding values from the provided object. If a placeholder doesn't have
+ * a corresponding value, it is left unchanged in the string.
+ *
+ * @param {string} input - The input string containing placeholders to be replaced.
+ * @param {Record<string, number | string>} values - An object containing key-value pairs for replacement.
+ * @return {string} The interpolated string with placeholders replaced by their corresponding values.
+ *
+ * @function patchPlaceholders
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant patchString
+ *   participant String.replace
+ *   Caller->>patchString: Call with input and values
+ *   patchString->>String.replace: Call with regex and replacement function
+ *   String.replace->>patchString: Return replaced string
+ *   patchString-->>Caller: Return patched string
+ *
+ * @memberOf module:TextUtils
+ */
+export declare function patchPlaceholders(input: string, values: Record<string, number | string>): string;
+export declare function patchString(input: string, values: Record<string, number | string>, flags?: string): string;
+/**
+ * @description Converts a string to camelCase.
+ * @summary Transforms the input string into camelCase format, where words are joined without spaces
+ * and each word after the first starts with a capital letter.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to camelCase.
+ *
+ * @function toCamelCase
+ *
+ * @memberOf module:TextUtils
+ */
+export declare function toCamelCase(text: string): string;
+/**
+ * @description Converts a string to ENVIRONMENT_VARIABLE format.
+ * @summary Transforms the input string into uppercase with words separated by underscores,
+ * typically used for environment variable names.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to ENVIRONMENT_VARIABLE format.
+ *
+ * @function toENVFormat
+ *
+ * @memberOf module:TextUtils
+ */
+export declare function toENVFormat(text: string): string;
+/**
+ * @description Converts a string to snake_case.
+ * @summary Transforms the input string into lowercase with words separated by underscores.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to snake_case.
+ *
+ * @function toSnakeCase
+ *
+ * @memberOf module:TextUtils
+ */
+export declare function toSnakeCase(text: string): string;
+/**
+ * @description Converts a string to kebab-case.
+ * @summary Transforms the input string into lowercase with words separated by hyphens.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to kebab-case.
+ *
+ * @function toKebabCase
+ *
+ * @memberOf module:TextUtils
+ */
+export declare function toKebabCase(text: string): string;
+/**
+ * @description Converts a string to PascalCase.
+ * @summary Transforms the input string into PascalCase format, where words are joined without spaces
+ * and each word starts with a capital letter.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to PascalCase.
+ *
+ * @function toPascalCase
+ *
+ * @memberOf module:TextUtils
+ */
+export declare function toPascalCase(text: string): string;
+export declare function escapeRegExp(string: string): string;

package/lib/utils/timeout.cjs

@@ -4,5 +4,4 @@ exports.awaitTimeout = awaitTimeout;
 async function awaitTimeout(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy91dGlscy90aW1lb3V0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsb0NBRUM7QUFGTSxLQUFLLFVBQVUsWUFBWSxDQUFDLEVBQVU7SUFDM0MsT0FBTyxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsVUFBVSxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDO0FBQzNELENBQUMiLCJmaWxlIjoidXRpbHMvdGltZW91dC5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBhc3luYyBmdW5jdGlvbiBhd2FpdFRpbWVvdXQobXM6IG51bWJlcik6IFByb21pc2U8dm9pZD4ge1xuICByZXR1cm4gbmV3IFByb21pc2UoKHJlc29sdmUpID0+IHNldFRpbWVvdXQocmVzb2x2ZSwgbXMpKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZW91dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy90aW1lb3V0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsb0NBRUM7QUFGTSxLQUFLLFVBQVUsWUFBWSxDQUFDLEVBQVU7SUFDM0MsT0FBTyxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsVUFBVSxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDO0FBQzNELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgYXN5bmMgZnVuY3Rpb24gYXdhaXRUaW1lb3V0KG1zOiBudW1iZXIpOiBQcm9taXNlPHZvaWQ+IHtcbiAgcmV0dXJuIG5ldyBQcm9taXNlKChyZXNvbHZlKSA9PiBzZXRUaW1lb3V0KHJlc29sdmUsIG1zKSk7XG59XG4iXX0=

package/lib/utils/timeout.d.ts

@@ -0,0 +1 @@
+export declare function awaitTimeout(ms: number): Promise<void>;

package/lib/utils/types.cjs

@@ -1,4 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,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