@decaf-ts/utils 0.1.6

package/lib/utils/tests.cjs

@@ -0,0 +1,263 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestReporter = exports.JestReportersTempPathEnvKey = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const fs_2 = require("./fs.cjs");
+exports.JestReportersTempPathEnvKey = "JEST_HTML_REPORTERS_TEMP_DIR_PATH";
+const dependencies = ["jest-html-reporters", "json2md", "chartjs-node-canvas"];
+async function normalizeImport(importPromise) {
+    // CommonJS's `module.exports` is wrapped as `default` in ESModule.
+    return importPromise.then((m) => (m.default || m));
+}
+/**
+ * @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
+ */
+class TestReporter {
+    constructor(testCase = "tests", basePath = path_1.default.join(process.cwd(), "workdocs", "reports", "evidences")) {
+        this.testCase = testCase;
+        this.basePath = basePath;
+        this.basePath = path_1.default.join(basePath, this.testCase);
+        if (!fs_1.default.existsSync(this.basePath)) {
+            fs_1.default.mkdirSync(basePath, { recursive: true });
+        }
+    }
+    /**
+     * @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
+     */
+    async importHelpers() {
+        this.deps = await (0, fs_2.installIfNotAvailable)([dependencies[0]], this.deps);
+        // if (!process.env[JestReportersTempPathEnvKey])
+        //   process.env[JestReportersTempPathEnvKey] = './workdocs/reports';
+        const { addMsg, addAttach } = await normalizeImport(Promise.resolve(`${`${dependencies[0]}/helper`}`).then(s => __importStar(require(s))));
+        TestReporter.addMsgFunction = addMsg;
+        TestReporter.addAttachFunction = addAttach;
+    }
+    /**
+     * @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
+     */
+    async reportMessage(title, message) {
+        if (!TestReporter.addMsgFunction)
+            await this.importHelpers();
+        const msg = `${title}${message ? `\n${message}` : ""}`;
+        await TestReporter.addMsgFunction({ message: msg });
+    }
+    /**
+     * @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
+     */
+    async reportAttachment(title, attachment) {
+        if (!TestReporter.addAttachFunction)
+            await this.importHelpers();
+        await TestReporter.addAttachFunction({
+            attach: attachment,
+            description: title,
+        });
+    }
+    /**
+     * @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
+     */
+    async report(reference, data, type, trim = false) {
+        try {
+            let attachFunction = this.reportMessage.bind(this);
+            let extension = ".txt";
+            switch (type) {
+                case "image":
+                    data = Buffer.from(data);
+                    extension = ".png";
+                    attachFunction = this.reportAttachment.bind(this);
+                    break;
+                case "json":
+                    if (trim) {
+                        if (data.request)
+                            delete data["request"];
+                        if (data.config)
+                            delete data["config"];
+                    }
+                    data = JSON.stringify(data, null, 2);
+                    extension = ".json";
+                    break;
+                case "md":
+                    extension = ".md";
+                    break;
+                case "text":
+                    extension = ".txt";
+                    break;
+                default:
+                    console.log(`Unsupported type ${type}. assuming text`);
+            }
+            reference = reference.includes("\n")
+                ? reference
+                : `${reference}${extension}`;
+            await attachFunction(reference, data);
+        }
+        catch (e) {
+            throw new Error(`Could not store attach artifact ${reference} under to test report ${this.testCase} - ${e}`);
+        }
+    }
+    async reportData(reference, data, type = "json", trim = false) {
+        return this.report(reference, data, type, trim);
+    }
+    async reportObject(reference, json, trim = false) {
+        return this.report(reference, json, "json", trim);
+    }
+    /**
+     * @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
+     */
+    async reportTable(reference, tableDef) {
+        this.deps = await (0, fs_2.installIfNotAvailable)([dependencies[1]], this.deps);
+        let txt;
+        try {
+            const json2md = await normalizeImport(Promise.resolve(`${`${dependencies[1]}`}`).then(s => __importStar(require(s))));
+            txt = json2md(tableDef);
+        }
+        catch (e) {
+            throw new Error(`Could not convert JSON to Markdown - ${e}`);
+        }
+        return this.report(reference, txt, "md");
+    }
+    /**
+     * @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
+     */
+    async reportGraph(reference, config) {
+        this.deps = await (0, fs_2.installIfNotAvailable)([dependencies[2]], this.deps);
+        const { ChartJSNodeCanvas } = await normalizeImport(Promise.resolve(`${dependencies[2]}`).then(s => __importStar(require(s))));
+        const width = 600; //px
+        const height = 800; //px
+        const backgroundColour = "white"; // Uses https://www.w3schools.com/tags/canvas_fillstyle.asp
+        const chartJSNodeCanvas = new ChartJSNodeCanvas({
+            width,
+            height,
+            backgroundColour,
+        });
+        const image = await chartJSNodeCanvas.renderToBuffer(config);
+        return await this.reportImage(reference, image);
+    }
+    /**
+     * @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
+     */
+    async reportImage(reference, buffer) {
+        return this.report(reference, buffer, "image");
+    }
+}
+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"]}

package/lib/utils/text.cjs

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.padEnd = padEnd;
+exports.patchPlaceholders = patchPlaceholders;
+exports.patchString = patchString;
+exports.toCamelCase = toCamelCase;
+exports.toENVFormat = toENVFormat;
+exports.toSnakeCase = toSnakeCase;
+exports.toKebabCase = toKebabCase;
+exports.toPascalCase = toPascalCase;
+exports.escapeRegExp = escapeRegExp;
+/**
+ * @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
+ */
+function padEnd(str, length, char = " ") {
+    if (char.length !== 1)
+        throw new Error("Invalid character length for padding. must be one!");
+    return str.padEnd(length, char);
+}
+/**
+ * @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
+ */
+function patchPlaceholders(input, values) {
+    return input.replace(/\$\{([a-zA-Z0-9_]+)\}/g, (match, variable) => values[variable] || match);
+}
+function patchString(input, values, flags = "g") {
+    Object.entries(values).forEach(([key, val]) => {
+        const regexp = new RegExp(escapeRegExp(key), flags);
+        input = input.replace(regexp, val);
+    });
+    return input;
+}
+/**
+ * @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
+ */
+function toCamelCase(text) {
+    return text
+        .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => index === 0 ? word.toLowerCase() : word.toUpperCase())
+        .replace(/\s+/g, "");
+}
+/**
+ * @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
+ */
+function toENVFormat(text) {
+    return toSnakeCase(text).toUpperCase();
+}
+/**
+ * @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
+ */
+function toSnakeCase(text) {
+    return text
+        .replace(/([a-z])([A-Z])/g, "$1_$2")
+        .replace(/[\s-]+/g, "_")
+        .toLowerCase();
+}
+/**
+ * @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
+ */
+function toKebabCase(text) {
+    return text
+        .replace(/([a-z])([A-Z])/g, "$1-$2")
+        .replace(/[\s_]+/g, "-")
+        .toLowerCase();
+}
+/**
+ * @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
+ */
+function toPascalCase(text) {
+    return text
+        .replace(/(?:^\w|[A-Z]|\b\w)/g, (word) => word.toUpperCase())
+        .replace(/\s+/g, "");
+}
+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"]}

package/lib/utils/timeout.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awaitTimeout = awaitTimeout;
+async function awaitTimeout(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy91dGlscy90aW1lb3V0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsb0NBRUM7QUFGTSxLQUFLLFVBQVUsWUFBWSxDQUFDLEVBQVU7SUFDM0MsT0FBTyxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsVUFBVSxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDO0FBQzNELENBQUMiLCJmaWxlIjoidXRpbHMvdGltZW91dC5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBhc3luYyBmdW5jdGlvbiBhd2FpdFRpbWVvdXQobXM6IG51bWJlcik6IFByb21pc2U8dm9pZD4ge1xuICByZXR1cm4gbmV3IFByb21pc2UoKHJlc29sdmUpID0+IHNldFRpbWVvdXQocmVzb2x2ZSwgbXMpKTtcbn1cbiJdfQ==

package/lib/utils/types.cjs

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