@decaf-ts/utils 0.1.6 → 0.2.0

package/lib/esm/utils/fs.js

@@ -98,6 +98,120 @@ export function writeFile(path, data) {
         throw new Error(`Error writing file "${path}": ${error}`);
     }
 }
+/**
+ * @description Retrieves all files recursively from a directory.
+ * @summary Traverses through directories and subdirectories to collect all file paths.
+ *
+ * @param {string} p - The path to start searching from.
+ * @param filter
+ * @return {string[]} Array of file paths.
+ *
+ * @function getAllFiles
+ *
+ * @memberOf module:fs-utils
+ */
+export function getAllFiles(p, filter) {
+    const log = logger.for(getAllFiles);
+    const files = [];
+    try {
+        log.verbose(`Retrieving all files from "${p}"...`);
+        const entries = fs.readdirSync(p);
+        entries.forEach((entry) => {
+            const fullPath = path.join(p, entry);
+            const stat = fs.statSync(fullPath);
+            if (stat.isFile()) {
+                files.push(fullPath);
+            }
+            else if (stat.isDirectory()) {
+                files.push(...getAllFiles(fullPath));
+            }
+        });
+        if (!filter)
+            return files;
+        return files.filter(filter);
+    }
+    catch (error) {
+        log.verbose(`Error retrieving files from "${p}": ${error}`);
+        throw new Error(`Error retrieving files from "${p}": ${error}`);
+    }
+}
+export async function renameFile(source, dest) {
+    const log = logger.for(renameFile);
+    let descriptorSource, descriptorDest;
+    try {
+        descriptorSource = fs.statSync(source);
+    }
+    catch (error) {
+        log.verbose(`Source path "${source}" does not exist: ${error}`);
+        throw new Error(`Source path "${source}" does not exist: ${error}`);
+    }
+    try {
+        descriptorDest = fs.statSync(dest);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (e) {
+        // do nothing. its ok
+    }
+    if (descriptorDest) {
+        log.verbose(`Destination path "${dest}" already exists`);
+        throw new Error(`Destination path "${dest}" already exists`);
+    }
+    try {
+        log.verbose(`Renaming ${descriptorSource.isFile() ? "file" : "directory"} "${source}" to "${dest}...`);
+        fs.renameSync(source, dest);
+        log.verbose(`Successfully renamed to "${dest}"`);
+    }
+    catch (error) {
+        log.verbose(`Error renaming ${descriptorSource.isFile() ? "file" : "directory"} "${source}" to "${dest}": ${error}`);
+        throw new Error(`Error renaming ${descriptorSource.isFile() ? "file" : "directory"} "${source}" to "${dest}": ${error}`);
+    }
+}
+export function copyFile(source, dest) {
+    const log = logger.for(copyFile);
+    let descriptorSource, descriptorDest;
+    try {
+        descriptorSource = fs.statSync(source);
+    }
+    catch (error) {
+        log.verbose(`Source path "${source}" does not exist: ${error}`);
+        throw new Error(`Source path "${source}" does not exist: ${error}`);
+    }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        descriptorDest = fs.statSync(dest);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (error) {
+        if (descriptorSource.isDirectory()) {
+            log.verbose(`Dest path "${dest}" does not exist. creating`);
+            fs.mkdirSync(dest, { recursive: true });
+        }
+    }
+    try {
+        log.verbose(`Copying ${descriptorSource.isFile() ? "file" : "directory"} "${source}" to "${dest}...`);
+        fs.cpSync(source, dest, { recursive: true });
+    }
+    catch (error) {
+        log.verbose(`Error copying ${descriptorSource.isFile() ? "file" : "directory"} "${source}" to "${dest}: ${error}`);
+        throw new Error(`Error copying ${descriptorSource.isFile() ? "file" : "directory"} "${source}" to "${dest}: ${error}`);
+    }
+}
+export function deletePath(p) {
+    const log = logger.for(deletePath);
+    try {
+        const descriptor = fs.statSync(p);
+        if (descriptor.isFile()) {
+            log.verbose(`Deleting file "${p}...`);
+            fs.rmSync(p, { recursive: true, force: true });
+        }
+        else if (descriptor.isDirectory())
+            fs.rmSync(p, { recursive: true, force: true });
+    }
+    catch (error) {
+        log.verbose(`Error Deleting "${p}": ${error}`);
+        throw new Error(`Error Deleting "${p}": ${error}`);
+    }
+}
 /**
  * @description Retrieves package information from package.json.
  * @summary Loads and parses the package.json file from a specified directory or the current working directory. Can return the entire package object or a specific property.
@@ -267,5 +381,4 @@ export async function normalizeImport(importPromise) {
     // CommonJS's `module.exports` is wrapped as `default` in ESModule.
     return importPromise.then((m) => (m.default || m));
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/utils/fs.ts"],"names":[],"mappings":"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","file":"utils/fs.js","sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\nimport { Logging } from \"../output/logging\";\nimport { patchString } from \"./text\";\nimport { runCommand } from \"./utils\";\nimport { DependencyMap, SimpleDependencyMap } from \"./types\";\n\nconst logger = Logging.for(\"fs\");\n\n/**\n * @description Patches a file with given values.\n * @summary Reads a file, applies patches using TextUtils, and writes the result back to the file.\n *\n * @param {string} path - The path to the file to be patched.\n * @param {Record<string, number | string>} values - The values to patch into the file.\n * @return {void}\n *\n * @function patchFile\n *\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant patchFile\n *   participant fs\n *   participant readFile\n *   participant TextUtils\n *   participant writeFile\n *   Caller->>patchFile: Call with path and values\n *   patchFile->>fs: Check if file exists\n *   patchFile->>readFile: Read file content\n *   readFile->>fs: Read file\n *   fs-->>readFile: Return file content\n *   readFile-->>patchFile: Return file content\n *   patchFile->>TextUtils: Patch string\n *   TextUtils-->>patchFile: Return patched content\n *   patchFile->>writeFile: Write patched content\n *   writeFile->>fs: Write to file\n *   fs-->>writeFile: File written\n *   writeFile-->>patchFile: File written\n *   patchFile-->>Caller: Patching complete\n *\n * @memberOf module:fs-utils\n */\nexport function patchFile(\n  path: string,\n  values: Record<string, number | string>\n) {\n  const log = logger.for(patchFile);\n  if (!fs.existsSync(path))\n    throw new Error(`File not found at path \"${path}\".`);\n  let content = readFile(path);\n\n  try {\n    log.verbose(`Patching file \"${path}\"...`);\n    log.debug(`with value: ${JSON.stringify(values)}`);\n    content = patchString(content, values);\n  } catch (error: unknown) {\n    throw new Error(`Error patching file: ${error}`);\n  }\n  writeFile(path, content);\n}\n\n/**\n * @description Reads a file and returns its content.\n * @summary Reads the content of a file at the specified path and returns it as a string.\n *\n * @param {string} path - The path to the file to be read.\n * @return {string} The content of the file.\n *\n * @function readFile\n *\n * @memberOf module:utils\n */\nexport function readFile(path: string): string {\n  const log = logger.for(readFile);\n  try {\n    log.verbose(`Reading file \"${path}\"...`);\n    return fs.readFileSync(path, \"utf8\");\n  } catch (error: unknown) {\n    log.verbose(`Error reading file \"${path}\": ${error}`);\n    throw new Error(`Error reading file \"${path}\": ${error}`);\n  }\n}\n\n/**\n * @description Writes data to a file.\n * @summary Writes the provided data to a file at the specified path.\n *\n * @param {string} path - The path to the file to be written.\n * @param {string | Buffer} data - The data to be written to the file.\n * @return {void}\n *\n * @function writeFile\n *\n * @memberOf module:utils\n */\nexport function writeFile(path: string, data: string | Buffer): void {\n  const log = logger.for(writeFile);\n  try {\n    log.verbose(`Writing file \"${path} with ${data.length} bytes...`);\n    fs.writeFileSync(path, data, \"utf8\");\n  } catch (error: unknown) {\n    log.verbose(`Error writing file \"${path}\": ${error}`);\n    throw new Error(`Error writing file \"${path}\": ${error}`);\n  }\n}\n\n/**\n * @description Retrieves package information from package.json.\n * @summary Loads and parses the package.json file from a specified directory or the current working directory. Can return the entire package object or a specific property.\n * @param {string} [p=process.cwd()] - The directory path where the package.json file is located.\n * @param {string} [property] - Optional. The specific property to retrieve from package.json.\n * @return {object | string} The parsed contents of package.json or the value of the specified property.\n * @function getPackage\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant getPackage\n *   participant readFile\n *   participant JSON\n *   Caller->>getPackage: Call with path and optional property\n *   getPackage->>readFile: Read package.json\n *   readFile-->>getPackage: Return file content\n *   getPackage->>JSON: Parse file content\n *   JSON-->>getPackage: Return parsed object\n *   alt property specified\n *     getPackage->>getPackage: Check if property exists\n *     alt property exists\n *       getPackage-->>Caller: Return property value\n *     else property doesn't exist\n *       getPackage-->>Caller: Throw Error\n *     end\n *   else no property specified\n *     getPackage-->>Caller: Return entire package object\n *   end\n * @memberOf module:utils\n */\nexport function getPackage(\n  p: string = process.cwd(),\n  property?: string\n): object | string {\n  let pkg: any;\n  try {\n    pkg = JSON.parse(readFile(path.join(p, `package.json`)));\n  } catch (error: unknown) {\n    throw new Error(`Failed to retrieve package information\" ${error}`);\n  }\n\n  if (property) {\n    if (!(property in pkg))\n      throw new Error(`Property \"${property}\" not found in package.json`);\n    return pkg[property] as string;\n  }\n  return pkg;\n}\n\nexport function setPackageAttribute(\n  attr: string,\n  value: string,\n  p: string = process.cwd()\n): void {\n  const pkg = getPackage(p) as Record<string, any>;\n  pkg[attr] = value;\n  writeFile(path.join(p, `package.json`), JSON.stringify(pkg, null, 2));\n}\n\n/**\n * @description Retrieves the version from package.json.\n * @summary A convenience function that calls getPackage to retrieve the \"version\" property from package.json.\n * @param {string} [p=process.cwd()] - The directory path where the package.json file is located.\n * @return {string} The version string from package.json.\n * @function getPackageVersion\n * @memberOf module:fs-utils\n */\nexport function getPackageVersion(p = process.cwd()): string {\n  return getPackage(p, \"version\") as string;\n}\n\n/**\n * @description Retrieves all dependencies from the project.\n * @summary Executes 'npm ls --json' command to get a detailed list of all dependencies (production, development, and peer) and their versions.\n * @param {string} [path=process.cwd()] - The directory path of the project.\n * @return {Promise<{prod: Array<{name: string, version: string}>, dev: Array<{name: string, version: string}>, peer: Array<{name: string, version: string}>}>} An object containing arrays of production, development, and peer dependencies.\n * @function getDependencies\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant getDependencies\n *   participant runCommand\n *   participant JSON\n *   Caller->>getDependencies: Call with optional path\n *   getDependencies->>runCommand: Execute 'npm ls --json'\n *   runCommand-->>getDependencies: Return command output\n *   getDependencies->>JSON: Parse command output\n *   JSON-->>getDependencies: Return parsed object\n *   getDependencies->>getDependencies: Process dependencies\n *   getDependencies-->>Caller: Return processed dependencies\n * @memberOf module:fs-utils\n */\nexport async function getDependencies(\n  path: string = process.cwd()\n): Promise<DependencyMap> {\n  let pkg: any;\n\n  try {\n    pkg = JSON.parse(await runCommand(`npm ls --json`, { cwd: path }).promise);\n  } catch (e: unknown) {\n    throw new Error(`Failed to retrieve dependencies: ${e}`);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  const mapper = (entry: [string, unknown], index: number) => ({\n    name: entry[0],\n    version: (entry[1] as any).version,\n  });\n\n  return {\n    prod: Object.entries(pkg.dependencies || {}).map(mapper),\n    dev: Object.entries(pkg.devDependencies || {}).map(mapper),\n    peer: Object.entries(pkg.peerDependencies || {}).map(mapper),\n  };\n}\n\nexport async function updateDependencies() {\n  const log = logger.for(updateDependencies);\n  log.info(\"checking for updates...\");\n  await runCommand(\"npx npm-check-updates -u\").promise;\n  log.info(\"updating...\");\n  await runCommand(\"npx npm run do-install\").promise;\n}\n\nexport async function installIfNotAvailable(\n  deps: string[] | string,\n  dependencies?: SimpleDependencyMap\n) {\n  if (!dependencies) {\n    const d: DependencyMap = await getDependencies();\n    dependencies = {\n      prod: d.prod?.map((p) => p.name) || [],\n      dev: d.dev?.map((d) => d.name) || [],\n      peer: d.peer?.map((p) => p.name) || [],\n    };\n  }\n  const { prod, dev, peer } = dependencies;\n  const installed = Array.from(\n    new Set([...(prod || []), ...(dev || []), ...(peer || [])])\n  );\n  deps = typeof deps === \"string\" ? [deps] : deps;\n  const toInstall = deps.filter((d) => !installed.includes(d));\n\n  if (toInstall.length) await installDependencies({ dev: toInstall });\n  dependencies.dev = dependencies.dev || [];\n  dependencies.dev.push(...toInstall);\n  return dependencies;\n}\n\nexport async function pushToGit() {\n  const log = logger.for(pushToGit);\n  const gitUser = await runCommand(\"git config user.name\").promise;\n  const gitEmail = await runCommand(\"git config user.email\").promise;\n  log.verbose(`cached git id: ${gitUser}/${gitEmail}. changing to automation`);\n  await runCommand('git config user.email \"automation@decaf.ts\"').promise;\n  await runCommand('git config user.name \"decaf\"').promise;\n  log.info(\"Pushing changes to git...\");\n  await runCommand(\"git add .\").promise;\n  await runCommand(`git commit -m \"refs #1 - after repo setup\"`).promise;\n  await runCommand(\"git push\").promise;\n  await runCommand(`git config user.email \"${gitEmail}\"`).promise;\n  await runCommand(`git config user.name \"${gitUser}\"`).promise;\n  log.verbose(`reverted to git id: ${gitUser}/${gitEmail}`);\n}\n\nexport async function installDependencies(dependencies: {\n  prod?: string[];\n  dev?: string[];\n  peer?: string[];\n}) {\n  const log = logger.for(installDependencies);\n  const prod = dependencies.prod || [];\n  const dev = dependencies.dev || [];\n  const peer = dependencies.peer || [];\n  if (prod.length) {\n    log.info(`Installing dependencies ${prod.join(\", \")}...`);\n    await runCommand(`npm install ${prod.join(\" \")}`, { cwd: process.cwd() })\n      .promise;\n  }\n  if (dev.length) {\n    log.info(`Installing devDependencies ${dev.join(\", \")}...`);\n    await runCommand(`npm install --save-dev ${dev.join(\" \")}`, {\n      cwd: process.cwd(),\n    }).promise;\n  }\n  if (peer.length) {\n    log.info(`Installing peerDependencies ${peer.join(\", \")}...`);\n    await runCommand(`npm install --save-peer ${peer.join(\" \")}`, {\n      cwd: process.cwd(),\n    }).promise;\n  }\n}\n\nexport async function normalizeImport<T>(\n  importPromise: Promise<T>\n): 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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fs.js","sourceRoot":"","sources":["../../../src/utils/fs.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\nimport { Logging } from \"../output/logging\";\nimport { patchString } from \"./text\";\nimport { runCommand } from \"./utils\";\nimport { DependencyMap, SimpleDependencyMap } from \"./types\";\n\nconst logger = Logging.for(\"fs\");\n\n/**\n * @description Patches a file with given values.\n * @summary Reads a file, applies patches using TextUtils, and writes the result back to the file.\n *\n * @param {string} path - The path to the file to be patched.\n * @param {Record<string, number | string>} values - The values to patch into the file.\n * @return {void}\n *\n * @function patchFile\n *\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant patchFile\n *   participant fs\n *   participant readFile\n *   participant TextUtils\n *   participant writeFile\n *   Caller->>patchFile: Call with path and values\n *   patchFile->>fs: Check if file exists\n *   patchFile->>readFile: Read file content\n *   readFile->>fs: Read file\n *   fs-->>readFile: Return file content\n *   readFile-->>patchFile: Return file content\n *   patchFile->>TextUtils: Patch string\n *   TextUtils-->>patchFile: Return patched content\n *   patchFile->>writeFile: Write patched content\n *   writeFile->>fs: Write to file\n *   fs-->>writeFile: File written\n *   writeFile-->>patchFile: File written\n *   patchFile-->>Caller: Patching complete\n *\n * @memberOf module:fs-utils\n */\nexport function patchFile(\n  path: string,\n  values: Record<string, number | string>\n) {\n  const log = logger.for(patchFile);\n  if (!fs.existsSync(path))\n    throw new Error(`File not found at path \"${path}\".`);\n  let content = readFile(path);\n\n  try {\n    log.verbose(`Patching file \"${path}\"...`);\n    log.debug(`with value: ${JSON.stringify(values)}`);\n    content = patchString(content, values);\n  } catch (error: unknown) {\n    throw new Error(`Error patching file: ${error}`);\n  }\n  writeFile(path, content);\n}\n\n/**\n * @description Reads a file and returns its content.\n * @summary Reads the content of a file at the specified path and returns it as a string.\n *\n * @param {string} path - The path to the file to be read.\n * @return {string} The content of the file.\n *\n * @function readFile\n *\n * @memberOf module:utils\n */\nexport function readFile(path: string): string {\n  const log = logger.for(readFile);\n  try {\n    log.verbose(`Reading file \"${path}\"...`);\n    return fs.readFileSync(path, \"utf8\");\n  } catch (error: unknown) {\n    log.verbose(`Error reading file \"${path}\": ${error}`);\n    throw new Error(`Error reading file \"${path}\": ${error}`);\n  }\n}\n\n/**\n * @description Writes data to a file.\n * @summary Writes the provided data to a file at the specified path.\n *\n * @param {string} path - The path to the file to be written.\n * @param {string | Buffer} data - The data to be written to the file.\n * @return {void}\n *\n * @function writeFile\n *\n * @memberOf module:utils\n */\nexport function writeFile(path: string, data: string | Buffer): void {\n  const log = logger.for(writeFile);\n  try {\n    log.verbose(`Writing file \"${path} with ${data.length} bytes...`);\n    fs.writeFileSync(path, data, \"utf8\");\n  } catch (error: unknown) {\n    log.verbose(`Error writing file \"${path}\": ${error}`);\n    throw new Error(`Error writing file \"${path}\": ${error}`);\n  }\n}\n\n/**\n * @description Retrieves all files recursively from a directory.\n * @summary Traverses through directories and subdirectories to collect all file paths.\n *\n * @param {string} p - The path to start searching from.\n * @param filter\n * @return {string[]} Array of file paths.\n *\n * @function getAllFiles\n *\n * @memberOf module:fs-utils\n */\nexport function getAllFiles(\n  p: string,\n  filter?: (f: string, i?: number) => boolean\n): string[] {\n  const log = logger.for(getAllFiles);\n  const files: string[] = [];\n\n  try {\n    log.verbose(`Retrieving all files from \"${p}\"...`);\n    const entries = fs.readdirSync(p);\n\n    entries.forEach((entry) => {\n      const fullPath = path.join(p, entry);\n      const stat = fs.statSync(fullPath);\n\n      if (stat.isFile()) {\n        files.push(fullPath);\n      } else if (stat.isDirectory()) {\n        files.push(...getAllFiles(fullPath));\n      }\n    });\n    if (!filter) return files;\n    return files.filter(filter);\n  } catch (error: unknown) {\n    log.verbose(`Error retrieving files from \"${p}\": ${error}`);\n    throw new Error(`Error retrieving files from \"${p}\": ${error}`);\n  }\n}\n\nexport async function renameFile(source: string, dest: string) {\n  const log = logger.for(renameFile);\n  let descriptorSource, descriptorDest;\n\n  try {\n    descriptorSource = fs.statSync(source);\n  } catch (error: unknown) {\n    log.verbose(`Source path \"${source}\" does not exist: ${error}`);\n    throw new Error(`Source path \"${source}\" does not exist: ${error}`);\n  }\n\n  try {\n    descriptorDest = fs.statSync(dest);\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (e: unknown) {\n    // do nothing. its ok\n  }\n  if (descriptorDest) {\n    log.verbose(`Destination path \"${dest}\" already exists`);\n    throw new Error(`Destination path \"${dest}\" already exists`);\n  }\n\n  try {\n    log.verbose(\n      `Renaming ${descriptorSource.isFile() ? \"file\" : \"directory\"} \"${source}\" to \"${dest}...`\n    );\n    fs.renameSync(source, dest);\n    log.verbose(`Successfully renamed to \"${dest}\"`);\n  } catch (error: unknown) {\n    log.verbose(\n      `Error renaming ${descriptorSource.isFile() ? \"file\" : \"directory\"} \"${source}\" to \"${dest}\": ${error}`\n    );\n    throw new Error(\n      `Error renaming ${descriptorSource.isFile() ? \"file\" : \"directory\"} \"${source}\" to \"${dest}\": ${error}`\n    );\n  }\n}\n\nexport function copyFile(source: string, dest: string) {\n  const log = logger.for(copyFile);\n  let descriptorSource, descriptorDest;\n  try {\n    descriptorSource = fs.statSync(source);\n  } catch (error: unknown) {\n    log.verbose(`Source path \"${source}\" does not exist: ${error}`);\n    throw new Error(`Source path \"${source}\" does not exist: ${error}`);\n  }\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    descriptorDest = fs.statSync(dest);\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (error: unknown) {\n    if (descriptorSource.isDirectory()) {\n      log.verbose(`Dest path \"${dest}\" does not exist. creating`);\n      fs.mkdirSync(dest, { recursive: true });\n    }\n  }\n\n  try {\n    log.verbose(\n      `Copying ${descriptorSource.isFile() ? \"file\" : \"directory\"} \"${source}\" to \"${dest}...`\n    );\n    fs.cpSync(source, dest, { recursive: true });\n  } catch (error: unknown) {\n    log.verbose(\n      `Error copying ${descriptorSource.isFile() ? \"file\" : \"directory\"} \"${source}\" to \"${dest}: ${error}`\n    );\n    throw new Error(\n      `Error copying ${descriptorSource.isFile() ? \"file\" : \"directory\"} \"${source}\" to \"${dest}: ${error}`\n    );\n  }\n}\n\nexport function deletePath(p: string) {\n  const log = logger.for(deletePath);\n  try {\n    const descriptor = fs.statSync(p);\n    if (descriptor.isFile()) {\n      log.verbose(`Deleting file \"${p}...`);\n      fs.rmSync(p, { recursive: true, force: true });\n    } else if (descriptor.isDirectory())\n      fs.rmSync(p, { recursive: true, force: true });\n  } catch (error: unknown) {\n    log.verbose(`Error Deleting \"${p}\": ${error}`);\n    throw new Error(`Error Deleting \"${p}\": ${error}`);\n  }\n}\n\n/**\n * @description Retrieves package information from package.json.\n * @summary Loads and parses the package.json file from a specified directory or the current working directory. Can return the entire package object or a specific property.\n * @param {string} [p=process.cwd()] - The directory path where the package.json file is located.\n * @param {string} [property] - Optional. The specific property to retrieve from package.json.\n * @return {object | string} The parsed contents of package.json or the value of the specified property.\n * @function getPackage\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant getPackage\n *   participant readFile\n *   participant JSON\n *   Caller->>getPackage: Call with path and optional property\n *   getPackage->>readFile: Read package.json\n *   readFile-->>getPackage: Return file content\n *   getPackage->>JSON: Parse file content\n *   JSON-->>getPackage: Return parsed object\n *   alt property specified\n *     getPackage->>getPackage: Check if property exists\n *     alt property exists\n *       getPackage-->>Caller: Return property value\n *     else property doesn't exist\n *       getPackage-->>Caller: Throw Error\n *     end\n *   else no property specified\n *     getPackage-->>Caller: Return entire package object\n *   end\n * @memberOf module:utils\n */\nexport function getPackage(\n  p: string = process.cwd(),\n  property?: string\n): object | string {\n  let pkg: any;\n  try {\n    pkg = JSON.parse(readFile(path.join(p, `package.json`)));\n  } catch (error: unknown) {\n    throw new Error(`Failed to retrieve package information\" ${error}`);\n  }\n\n  if (property) {\n    if (!(property in pkg))\n      throw new Error(`Property \"${property}\" not found in package.json`);\n    return pkg[property] as string;\n  }\n  return pkg;\n}\n\nexport function setPackageAttribute(\n  attr: string,\n  value: string,\n  p: string = process.cwd()\n): void {\n  const pkg = getPackage(p) as Record<string, any>;\n  pkg[attr] = value;\n  writeFile(path.join(p, `package.json`), JSON.stringify(pkg, null, 2));\n}\n\n/**\n * @description Retrieves the version from package.json.\n * @summary A convenience function that calls getPackage to retrieve the \"version\" property from package.json.\n * @param {string} [p=process.cwd()] - The directory path where the package.json file is located.\n * @return {string} The version string from package.json.\n * @function getPackageVersion\n * @memberOf module:fs-utils\n */\nexport function getPackageVersion(p = process.cwd()): string {\n  return getPackage(p, \"version\") as string;\n}\n\n/**\n * @description Retrieves all dependencies from the project.\n * @summary Executes 'npm ls --json' command to get a detailed list of all dependencies (production, development, and peer) and their versions.\n * @param {string} [path=process.cwd()] - The directory path of the project.\n * @return {Promise<{prod: Array<{name: string, version: string}>, dev: Array<{name: string, version: string}>, peer: Array<{name: string, version: string}>}>} An object containing arrays of production, development, and peer dependencies.\n * @function getDependencies\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant getDependencies\n *   participant runCommand\n *   participant JSON\n *   Caller->>getDependencies: Call with optional path\n *   getDependencies->>runCommand: Execute 'npm ls --json'\n *   runCommand-->>getDependencies: Return command output\n *   getDependencies->>JSON: Parse command output\n *   JSON-->>getDependencies: Return parsed object\n *   getDependencies->>getDependencies: Process dependencies\n *   getDependencies-->>Caller: Return processed dependencies\n * @memberOf module:fs-utils\n */\nexport async function getDependencies(\n  path: string = process.cwd()\n): Promise<DependencyMap> {\n  let pkg: any;\n\n  try {\n    pkg = JSON.parse(await runCommand(`npm ls --json`, { cwd: path }).promise);\n  } catch (e: unknown) {\n    throw new Error(`Failed to retrieve dependencies: ${e}`);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  const mapper = (entry: [string, unknown], index: number) => ({\n    name: entry[0],\n    version: (entry[1] as any).version,\n  });\n\n  return {\n    prod: Object.entries(pkg.dependencies || {}).map(mapper),\n    dev: Object.entries(pkg.devDependencies || {}).map(mapper),\n    peer: Object.entries(pkg.peerDependencies || {}).map(mapper),\n  };\n}\n\nexport async function updateDependencies() {\n  const log = logger.for(updateDependencies);\n  log.info(\"checking for updates...\");\n  await runCommand(\"npx npm-check-updates -u\").promise;\n  log.info(\"updating...\");\n  await runCommand(\"npx npm run do-install\").promise;\n}\n\nexport async function installIfNotAvailable(\n  deps: string[] | string,\n  dependencies?: SimpleDependencyMap\n) {\n  if (!dependencies) {\n    const d: DependencyMap = await getDependencies();\n    dependencies = {\n      prod: d.prod?.map((p) => p.name) || [],\n      dev: d.dev?.map((d) => d.name) || [],\n      peer: d.peer?.map((p) => p.name) || [],\n    };\n  }\n  const { prod, dev, peer } = dependencies;\n  const installed = Array.from(\n    new Set([...(prod || []), ...(dev || []), ...(peer || [])])\n  );\n  deps = typeof deps === \"string\" ? [deps] : deps;\n  const toInstall = deps.filter((d) => !installed.includes(d));\n\n  if (toInstall.length) await installDependencies({ dev: toInstall });\n  dependencies.dev = dependencies.dev || [];\n  dependencies.dev.push(...toInstall);\n  return dependencies;\n}\n\nexport async function pushToGit() {\n  const log = logger.for(pushToGit);\n  const gitUser = await runCommand(\"git config user.name\").promise;\n  const gitEmail = await runCommand(\"git config user.email\").promise;\n  log.verbose(`cached git id: ${gitUser}/${gitEmail}. changing to automation`);\n  await runCommand('git config user.email \"automation@decaf.ts\"').promise;\n  await runCommand('git config user.name \"decaf\"').promise;\n  log.info(\"Pushing changes to git...\");\n  await runCommand(\"git add .\").promise;\n  await runCommand(`git commit -m \"refs #1 - after repo setup\"`).promise;\n  await runCommand(\"git push\").promise;\n  await runCommand(`git config user.email \"${gitEmail}\"`).promise;\n  await runCommand(`git config user.name \"${gitUser}\"`).promise;\n  log.verbose(`reverted to git id: ${gitUser}/${gitEmail}`);\n}\n\nexport async function installDependencies(dependencies: {\n  prod?: string[];\n  dev?: string[];\n  peer?: string[];\n}) {\n  const log = logger.for(installDependencies);\n  const prod = dependencies.prod || [];\n  const dev = dependencies.dev || [];\n  const peer = dependencies.peer || [];\n  if (prod.length) {\n    log.info(`Installing dependencies ${prod.join(\", \")}...`);\n    await runCommand(`npm install ${prod.join(\" \")}`, { cwd: process.cwd() })\n      .promise;\n  }\n  if (dev.length) {\n    log.info(`Installing devDependencies ${dev.join(\", \")}...`);\n    await runCommand(`npm install --save-dev ${dev.join(\" \")}`, {\n      cwd: process.cwd(),\n    }).promise;\n  }\n  if (peer.length) {\n    log.info(`Installing peerDependencies ${peer.join(\", \")}...`);\n    await runCommand(`npm install --save-peer ${peer.join(\" \")}`, {\n      cwd: process.cwd(),\n    }).promise;\n  }\n}\n\nexport async function normalizeImport<T>(\n  importPromise: Promise<T>\n): 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"]}

package/lib/esm/utils/http.js

@@ -66,5 +66,4 @@ export class HttpClient {
         });
     }
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/utils/index.js

@@ -5,5 +5,4 @@ export * from "./http";
 export * from "./text";
 export * from "./types";
 export * from "./utils";
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLE1BQU0sQ0FBQztBQUNyQixjQUFjLFFBQVEsQ0FBQztBQUN2QixjQUFjLFFBQVEsQ0FBQztBQUN2QixjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLFNBQVMsQ0FBQyIsImZpbGUiOiJ1dGlscy9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZW52aXJvbm1lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ZzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9odHRwXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90ZXh0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHNcIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxNQUFNLENBQUM7QUFDckIsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2Vudmlyb25tZW50XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9mc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vaHR0cFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdGV4dFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHlwZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG4iXX0=

package/lib/esm/utils/md.js

@@ -1,3 +1,2 @@
 export {};
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy91dGlscy9tZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwiZmlsZSI6InV0aWxzL21kLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZGVzY3JpcHRpb24gU2luZ2xlIGxpbmUgbWFya2Rvd24gZWxlbWVudCB0eXBlXG4gKiBAc3VtbWFyeSBSZXByZXNlbnRzIHRoZSBwb3NzaWJsZSBoZWFkZXIgbGV2ZWxzIGluIG1hcmtkb3duXG4gKiBAdHlwZWRlZiB7XCJoMVwifFwiaDJcInxcImgzXCJ8XCJoNFwifFwiaDVcInxcImg2XCJ9IE1kU2luZ2xlTGluZUVsZW1lbnRcbiAqIEBtZW1iZXJPZiBAZGVjYWYtdHMvdXRpbHNcbiAqL1xuZXhwb3J0IHR5cGUgTWRTaW5nbGVMaW5lRWxlbWVudCA9IFwiaDFcIiB8IFwiaDJcIiB8IFwiaDNcIiB8IFwiaDRcIiB8IFwiaDVcIiB8IFwiaDZcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gTXVsdGktbGluZSBlbGVtZW50IHR5cGVzIGluIG1hcmtkb3duXG4gKiBAc3VtbWFyeSBEZWZpbmVzIHRoZSBhdmFpbGFibGUgbXVsdGktbGluZSBlbGVtZW50IHR5cGVzXG4gKiBAdHlwZWRlZiB7XCJwXCJ8XCJibG9ja3F1b3RlXCJ9IE1kTXVsdGlMaW5lRWxlbWVudFxuICogQG1lbWJlck9mIEBkZWNhZi10cy91dGlsc1xuICovXG5leHBvcnQgdHlwZSBNZE11bHRpTGluZUVsZW1lbnQgPSBcInBcIiB8IFwiYmxvY2txdW90ZVwiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBMaXN0IGVsZW1lbnQgdHlwZXMgaW4gbWFya2Rvd25cbiAqIEBzdW1tYXJ5IERlZmluZXMgdGhlIGF2YWlsYWJsZSBsaXN0IHR5cGVzXG4gKiBAdHlwZWRlZiB7XCJ1bFwifFwib2xcIn0gTWRMaXN0RWxlbWVudFxuICogQG1lbWJlck9mIEBkZWNhZi10cy91dGlsc1xuICovXG5leHBvcnQgdHlwZSBNZExpc3RFbGVtZW50ID0gXCJ1bFwiIHwgXCJvbFwiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBMaXN0IGVsZW1lbnQgdHlwZXMgaW4gbWFya2Rvd25cbiAqIEBzdW1tYXJ5IERlZmluZXMgdGhlIGF2YWlsYWJsZSBsaXN0IHR5cGVzXG4gKiBAdHlwZWRlZiB7T2JqZWN0fSBNZFNpbmdsZUxpbmVcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBbdWxdIC0gdW5vcmRlcmVkIGxpc3RcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBbb2xdIC0gb3JkZXJlZCBsaXN0XG4gKiBAbWVtYmVyT2YgQGRlY2FmLXRzL3V0aWxzXG4gKi9cbmV4cG9ydCB0eXBlIE1kU2luZ2xlTGluZSA9IHtcbiAgW2sgaW4gTWRTaW5nbGVMaW5lRWxlbWVudF0/OiBzdHJpbmc7XG59O1xuLyoqXG4gKiBAZGVzY3JpcHRpb24gTXVsdGktbGluZSBtYXJrZG93biBlbGVtZW50IHR5cGVcbiAqIEBzdW1tYXJ5IFJlcHJlc2VudHMgbWFya2Rvd24gZWxlbWVudHMgdGhhdCBjYW4gY29udGFpbiBtdWx0aXBsZSBsaW5lcyBvZiB0ZXh0XG4gKiBAdHlwZWRlZiB7T2JqZWN0fSBNZE11bHRpTGluZVxuICogQHByb3BlcnR5IHtzdHJpbmd8c3RyaW5nW119IFtwXSAtIFBhcmFncmFwaCBjb250ZW50XG4gKiBAcHJvcGVydHkge3N0cmluZ3xzdHJpbmdbXX0gW2Jsb2NrcXVvdGVdIC0gQmxvY2txdW90ZSBjb250ZW50XG4gKiBAbWVtYmVyT2YgQGRlY2FmLXRzL3V0aWxzXG4gKi9cbmV4cG9ydCB0eXBlIE1kTXVsdGlMaW5lID0geyBbayBpbiBNZE11bHRpTGluZUVsZW1lbnRdPzogc3RyaW5nIHwgc3RyaW5nW10gfTtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gSW1hZ2UgZGVmaW5pdGlvbiB0eXBlIGluIG1hcmtkb3duXG4gKiBAc3VtbWFyeSBEZWZpbmVzIHRoZSBzdHJ1Y3R1cmUgZm9yIGltYWdlIGVsZW1lbnRzXG4gKiBAdHlwZWRlZiB7T2JqZWN0fSBNZEltYWdlRGVmaW5pdGlvblxuICogQHByb3BlcnR5IHtzdHJpbmd9IFt0aXRsZV0gLSBPcHRpb25hbCBpbWFnZSB0aXRsZVxuICogQHByb3BlcnR5IHtzdHJpbmd9IHNvdXJjZSAtIEltYWdlIHNvdXJjZSBVUkxcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBbYWx0XSAtIE9wdGlvbmFsIGFsdGVybmF0aXZlIHRleHRcbiAqIEBtZW1iZXJPZiBAZGVjYWYtdHMvdXRpbHNcbiAqL1xuZXhwb3J0IHR5cGUgTWRJbWFnZURlZmluaXRpb24gPSB7XG4gIHRpdGxlPzogc3RyaW5nO1xuICBzb3VyY2U6IHN0cmluZztcbiAgYWx0Pzogc3RyaW5nO1xufTtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gSW1hZ2UgZWxlbWVudCB0eXBlIGluIG1hcmtkb3duXG4gKiBAc3VtbWFyeSBSZXByZXNlbnRzIGFuIGltYWdlIGVsZW1lbnQgd2l0aCBpdHMgcHJvcGVydGllc1xuICogQHR5cGVkZWYge09iamVjdH0gTWRJbWFnZVxuICogQHByb3BlcnR5IHtNZEltYWdlRGVmaW5pdGlvbn0gaW1nIC0gVGhlIGltYWdlIGRlZmluaXRpb24gb2JqZWN0XG4gKiBAbWVtYmVyT2YgQGRlY2FmLXRzL3V0aWxzXG4gKi9cbmV4cG9ydCB0eXBlIE1kSW1hZ2UgPSB7IGltZzogTWRJbWFnZURlZmluaXRpb24gfTtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gTGlzdCBpdGVtIGVsZW1lbnQgdHlwZSBpbiBtYXJrZG93blxuICogQHN1bW1hcnkgUmVwcmVzZW50cyBvcmRlcmVkIGFuZCB1bm9yZGVyZWQgbGlzdHMgaW4gbWFya2Rvd25cbiAqIEB0eXBlZGVmIHtPYmplY3R9IE1kTGlzdEl0ZW1cbiAqIEBwcm9wZXJ0eSB7c3RyaW5nW119IHVsIC0gVW5vcmRlcmVkIGxpc3QgaXRlbXNcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nW119IG9sIC0gT3JkZXJlZCBsaXN0IGl0ZW1zXG4gKiBAbWVtYmVyT2YgQGRlY2FmLXRzL3V0aWxzXG4gKi9cbmV4cG9ydCB0eXBlIE1kTGlzdEl0ZW0gPSB7IFtrIGluIE1kTGlzdEVsZW1lbnRdOiBzdHJpbmdbXSB9O1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBUYWJsZSBkZWZpbml0aW9uIHR5cGUgaW4gbWFya2Rvd25cbiAqIEBzdW1tYXJ5IERlZmluZXMgdGhlIHN0cnVjdHVyZSBmb3IgdGFibGUgZWxlbWVudHNcbiAqIEB0eXBlZGVmIHtPYmplY3R9IE1kVGFibGVEZWZpbml0aW9uXG4gKiBAcHJvcGVydHkge3N0cmluZ1tdfSBoZWFkZXJzIC0gQXJyYXkgb2YgdGFibGUgaGVhZGVyIG5hbWVzXG4gKiBAcHJvcGVydHkge09iamVjdFtdfSByb3dzIC0gQXJyYXkgb2Ygcm93IG9iamVjdHMgY29udGFpbmluZyBjb2x1bW4gdmFsdWVzXG4gKiBAbWVtYmVyT2YgQGRlY2FmLXRzL3V0aWxzXG4gKi9cbmV4cG9ydCB0eXBlIE1kVGFibGVEZWZpbml0aW9uID0ge1xuICBoZWFkZXJzOiBzdHJpbmdbXTtcbiAgcm93czogeyBbY29sdW1uOiBzdHJpbmddOiBzdHJpbmcgfCBzdHJpbmdbXSB9W107XG59O1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBUYWJsZSBlbGVtZW50IHR5cGUgaW4gbWFya2Rvd25cbiAqIEBzdW1tYXJ5IFJlcHJlc2VudHMgYSB0YWJsZSBzdHJ1Y3R1cmUgd2l0aCBoZWFkZXJzIGFuZCByb3dzXG4gKiBAdHlwZWRlZiB7T2JqZWN0fSBNZFRhYmxlXG4gKiBAcHJvcGVydHkge01kVGFibGVEZWZpbml0aW9ufSB0YWJsZSAtIFRoZSB0YWJsZSBkZWZpbml0aW9uIG9iamVjdFxuICogQG1lbWJlck9mIEBkZWNhZi10cy91dGlsc1xuICovXG5leHBvcnQgdHlwZSBNZFRhYmxlID0geyB0YWJsZTogTWRUYWJsZURlZmluaXRpb24gfTtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gQ29kZSBibG9jayBkZWZpbml0aW9uIHR5cGUgaW4gbWFya2Rvd25cbiAqIEBzdW1tYXJ5IERlZmluZXMgdGhlIHN0cnVjdHVyZSBmb3IgY29kZSBibG9ja3NcbiAqIEB0eXBlZGVmIHtPYmplY3R9IE1kQ29kZURlZmluaXRpb25cbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBbbGFuZ3VhZ2VdIC0gT3B0aW9uYWwgcHJvZ3JhbW1pbmcgbGFuZ3VhZ2Ugc3BlY2lmaWNhdGlvblxuICogQHByb3BlcnR5IHtzdHJpbmd8c3RyaW5nW119IGNvbnRlbnQgLSBUaGUgY29kZSBjb250ZW50IGFzIHN0cmluZyBvciBhcnJheSBvZiBzdHJpbmdzXG4gKiBAbWVtYmVyT2YgQGRlY2FmLXRzL3V0aWxzXG4gKi9cbmV4cG9ydCB0eXBlIE1kQ29kZURlZmluaXRpb24gPSB7XG4gIGxhbmd1YWdlPzogc3RyaW5nO1xuICBjb250ZW50OiBzdHJpbmcgfCBzdHJpbmdbXTtcbn07XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIENvZGUgYmxvY2sgZWxlbWVudCB0eXBlIGluIG1hcmtkb3duXG4gKiBAc3VtbWFyeSBSZXByZXNlbnRzIGEgY29kZSBibG9jayB3aXRoIG9wdGlvbmFsIGxhbmd1YWdlIHNwZWNpZmljYXRpb25cbiAqIEB0eXBlZGVmIHtPYmplY3R9IE1kQ29kZVxuICogQHByb3BlcnR5IHtNZENvZGVEZWZpbml0aW9ufSBjb2RlIC0gVGhlIGNvZGUgYmxvY2sgZGVmaW5pdGlvbiBvYmplY3RcbiAqIEBtZW1iZXJPZiBAZGVjYWYtdHMvdXRpbHNcbiAqL1xuZXhwb3J0IHR5cGUgTWRDb2RlID0geyBjb2RlOiBNZENvZGVEZWZpbml0aW9uIH07XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEhvcml6b250YWwgcnVsZSBlbGVtZW50IHR5cGUgaW4gbWFya2Rvd25cbiAqIEBzdW1tYXJ5IFJlcHJlc2VudHMgYSBob3Jpem9udGFsIHJ1bGUgc2VwYXJhdG9yXG4gKiBAdHlwZWRlZiB7T2JqZWN0fSBNZFNlcGFyYXRvclxuICogQHByb3BlcnR5IHtzdHJpbmd9IGhyIC0gVGhlIGhvcml6b250YWwgcnVsZSByZXByZXNlbnRhdGlvblxuICogQG1lbWJlck9mIEBkZWNhZi10cy91dGlsc1xuICovXG5leHBvcnQgdHlwZSBNZFNlcGFyYXRvciA9IHsgaHI6IHN0cmluZyB9O1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBMaW5rIGVsZW1lbnQgdHlwZSBpbiBtYXJrZG93blxuICogQHN1bW1hcnkgUmVwcmVzZW50cyBhIGh5cGVybGluayB3aXRoIHRpdGxlIGFuZCBzb3VyY2VcbiAqIEB0eXBlZGVmIHtPYmplY3R9IE1kTGlua1xuICogQHByb3BlcnR5IHt7dGl0bGU6IHN0cmluZywgc291cmNlOiBzdHJpbmd9fSBsaW5rIC0gVGhlIGxpbmsgZGVmaW5pdGlvbiBvYmplY3RcbiAqIEBtZW1iZXJPZiBAZGVjYWYtdHMvdXRpbHNcbiAqL1xuZXhwb3J0IHR5cGUgTWRMaW5rID0ge1xuICBsaW5rOiB7XG4gICAgdGl0bGU6IHN0cmluZztcbiAgICBzb3VyY2U6IHN0cmluZztcbiAgfTtcbn07XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIE1hcmtkb3duIGVsZW1lbnQgdHlwZSBkZWZpbml0aW9uXG4gKiBAc3VtbWFyeSBSZXByZXNlbnRzIGFsbCBwb3NzaWJsZSBtYXJrZG93biBlbGVtZW50cyB0aGF0IGNhbiBiZSB1c2VkIGluIGRvY3VtZW50IGdlbmVyYXRpb24uXG4gKiBUaGlzIHR5cGUgY29tYmluZXMgdmFyaW91cyBtYXJrZG93biBlbGVtZW50cyBpbmNsdWRpbmcgaGVhZGVycywgcGFyYWdyYXBocywgaW1hZ2VzLCBsaXN0cyxcbiAqIHRhYmxlcywgY29kZSBibG9ja3MsIHNlcGFyYXRvcnMsIGFuZCBsaW5rcyBpbnRvIGEgdW5pb24gdHlwZSBmb3IgZmxleGlibGUgbWFya2Rvd24gY29udGVudCBjcmVhdGlvbi5cbiAqIEB0eXBlZGVmIHsoTWRTaW5nbGVMaW5lIHwgTWRNdWx0aUxpbmUgfCBNZEltYWdlIHwgTWRMaXN0SXRlbSB8IE1kVGFibGUgfCBNZENvZGUgfCBNZFNlcGFyYXRvciB8IE1kTGluayl9IE1kRWxlbWVudHNcbiAqIEBtZW1iZXJPZiBAZGVjYWYtdHMvdXRpbHNcbiAqL1xuZXhwb3J0IHR5cGUgTWRFbGVtZW50cyA9XG4gIHwgTWRTaW5nbGVMaW5lXG4gIHwgTWRNdWx0aUxpbmVcbiAgfCBNZEltYWdlXG4gIHwgTWRMaXN0SXRlbVxuICB8IE1kVGFibGVcbiAgfCBNZENvZGVcbiAgfCBNZFNlcGFyYXRvclxuICB8IE1kTGluaztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/utils/tests.js

@@ -219,5 +219,4 @@ export class TestReporter {
         return this.report(reference, buffer, "image");
     }
 }
-
-//# 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/esm/utils/text.js

@@ -138,5 +138,4 @@ export function toPascalCase(text) {
 export 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":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,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,MAAM,UAAU,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,MAAM,UAAU,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,MAAM,UAAU,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,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;AACzC,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,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,MAAM,UAAU,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,MAAM,UAAU,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,MAAM,UAAU,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":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,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,MAAM,UAAU,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,MAAM,UAAU,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,MAAM,UAAU,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,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;AACzC,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,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,MAAM,UAAU,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,MAAM,UAAU,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,MAAM,UAAU,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/esm/utils/timeout.js

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

package/lib/esm/utils/types.js

@@ -1,3 +1,2 @@
 export {};
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,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