@settlemint/sdk-utils 2.3.2-pr708c218f → 2.3.2-pr74f654b5

package/dist/terminal.cjs

@@ -1,279 +1,112 @@
-"use strict";
+//#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/terminal.ts
-var terminal_exports = {};
-__export(terminal_exports, {
-  CancelError: () => CancelError,
-  CommandError: () => CommandError,
-  SpinnerError: () => SpinnerError,
-  ascii: () => ascii,
-  cancel: () => cancel,
-  executeCommand: () => executeCommand,
-  intro: () => intro,
-  list: () => list,
-  maskTokens: () => maskTokens,
-  note: () => note,
-  outro: () => outro,
-  spinner: () => spinner,
-  table: () => table
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const src_terminal_ascii_js = __toESM(require("./terminal/ascii.js"));
+const src_terminal_cancel_js = __toESM(require("./terminal/cancel.js"));
+const src_terminal_execute_command_js = __toESM(require("./terminal/execute-command.js"));
+const src_terminal_intro_js = __toESM(require("./terminal/intro.js"));
+const src_terminal_list_js = __toESM(require("./terminal/list.js"));
+const src_terminal_note_js = __toESM(require("./terminal/note.js"));
+const src_terminal_outro_js = __toESM(require("./terminal/outro.js"));
+const src_terminal_spinner_js = __toESM(require("./terminal/spinner.js"));
+const src_terminal_table_js = __toESM(require("./terminal/table.js"));
+const src_logging_mask_tokens_js = __toESM(require("./logging/mask-tokens.js"));
+
+Object.defineProperty(exports, 'CancelError', {
+  enumerable: true,
+  get: function () {
+    return src_terminal_cancel_js.CancelError;
+  }
 });
-module.exports = __toCommonJS(terminal_exports);
-
-// src/terminal/ascii.ts
-var import_yoctocolors = require("yoctocolors");
-
-// src/terminal/should-print.ts
-function shouldPrint() {
-  return process.env.SETTLEMINT_DISABLE_TERMINAL !== "true";
-}
-
-// src/terminal/ascii.ts
-var ascii = () => {
-  if (!shouldPrint()) {
-    return;
+Object.defineProperty(exports, 'CommandError', {
+  enumerable: true,
+  get: function () {
+    return src_terminal_execute_command_js.CommandError;
   }
-  console.log(
-    (0, import_yoctocolors.magentaBright)(`
-  _________       __    __  .__            _____  .__        __
- /   _____/ _____/  |__/  |_|  |   ____   /     \\ |__| _____/  |_
- \\_____  \\_/ __ \\   __\\   __\\  | _/ __ \\ /  \\ /  \\|  |/    \\   __\\
- /        \\  ___/|  |  |  | |  |_\\  ___//    Y    \\  |   |  \\  |
-/_________/\\_____>__|  |__| |____/\\_____>____|____/__|___|__/__|
-`)
-  );
-};
-
-// src/logging/mask-tokens.ts
-var maskTokens = (output) => {
-  return output.replace(/sm_(pat|aat|sat)_[0-9a-zA-Z]+/g, "***");
-};
-
-// src/terminal/cancel.ts
-var import_yoctocolors2 = require("yoctocolors");
-var CancelError = class extends Error {
-};
-var cancel = (msg) => {
-  console.log("");
-  console.log((0, import_yoctocolors2.inverse)((0, import_yoctocolors2.redBright)(maskTokens(msg))));
-  console.log("");
-  throw new CancelError(msg);
-};
-
-// src/terminal/execute-command.ts
-var import_node_child_process = require("child_process");
-var CommandError = class extends Error {
-  /**
-   * Constructs a new CommandError
-   * @param message - The error message
-   * @param code - The exit code of the command
-   * @param output - The output of the command
-   */
-  constructor(message, code, output) {
-    super(message);
-    this.code = code;
-    this.output = output;
+});
+Object.defineProperty(exports, 'SpinnerError', {
+  enumerable: true,
+  get: function () {
+    return src_terminal_spinner_js.SpinnerError;
   }
-};
-async function executeCommand(command, args, options) {
-  const { silent, ...spawnOptions } = options ?? {};
-  const child = (0, import_node_child_process.spawn)(command, args, { ...spawnOptions, env: { ...process.env, ...options?.env } });
-  process.stdin.pipe(child.stdin);
-  const output = [];
-  return new Promise((resolve, reject) => {
-    child.stdout.on("data", (data) => {
-      const maskedData = maskTokens(data.toString());
-      if (!silent) {
-        process.stdout.write(maskedData);
-      }
-      output.push(maskedData);
-    });
-    child.stderr.on("data", (data) => {
-      const maskedData = maskTokens(data.toString());
-      if (!silent) {
-        process.stderr.write(maskedData);
-      }
-      output.push(maskedData);
-    });
-    child.on(
-      "error",
-      (err) => reject(new CommandError(err.message, "code" in err && typeof err.code === "number" ? err.code : 1, output))
-    );
-    child.on("close", (code) => {
-      if (code === 0 || code === null || code === 143) {
-        process.stdin.unpipe(child.stdin);
-        resolve(output);
-        return;
-      }
-      reject(new CommandError(`Command "${command}" exited with code ${code}`, code, output));
-    });
-  });
-}
-
-// src/terminal/intro.ts
-var import_yoctocolors3 = require("yoctocolors");
-var intro = (msg) => {
-  if (!shouldPrint()) {
-    return;
+});
+Object.defineProperty(exports, 'ascii', {
+  enumerable: true,
+  get: function () {
+    return src_terminal_ascii_js.ascii;
   }
-  console.log("");
-  console.log((0, import_yoctocolors3.magentaBright)(maskTokens(msg)));
-  console.log("");
-};
-
-// src/terminal/note.ts
-var import_yoctocolors4 = require("yoctocolors");
-var note = (message, level = "info") => {
-  if (!shouldPrint()) {
-    return;
+});
+Object.defineProperty(exports, 'cancel', {
+  enumerable: true,
+  get: function () {
+    return src_terminal_cancel_js.cancel;
   }
-  const maskedMessage = maskTokens(message);
-  console.log("");
-  if (level === "warn") {
-    console.warn((0, import_yoctocolors4.yellowBright)(maskedMessage));
-    return;
+});
+Object.defineProperty(exports, 'executeCommand', {
+  enumerable: true,
+  get: function () {
+    return src_terminal_execute_command_js.executeCommand;
   }
-  console.log(maskedMessage);
-};
-
-// src/terminal/list.ts
-function list(title, items) {
-  const formatItems = (items2) => {
-    return items2.map((item) => {
-      if (Array.isArray(item)) {
-        return item.map((subItem) => `    \u2022 ${subItem}`).join("\n");
-      }
-      return `  \u2022 ${item}`;
-    }).join("\n");
-  };
-  return note(`${title}:
-
-${formatItems(items)}`);
-}
-
-// src/terminal/outro.ts
-var import_yoctocolors5 = require("yoctocolors");
-var outro = (msg) => {
-  if (!shouldPrint()) {
-    return;
+});
+Object.defineProperty(exports, 'intro', {
+  enumerable: true,
+  get: function () {
+    return src_terminal_intro_js.intro;
   }
-  console.log("");
-  console.log((0, import_yoctocolors5.inverse)((0, import_yoctocolors5.greenBright)(maskTokens(msg))));
-  console.log("");
-};
-
-// src/terminal/spinner.ts
-var import_is_in_ci = __toESM(require("is-in-ci"), 1);
-var import_yocto_spinner = __toESM(require("yocto-spinner"), 1);
-var import_yoctocolors6 = require("yoctocolors");
-var SpinnerError = class extends Error {
-  constructor(message, originalError) {
-    super(message);
-    this.originalError = originalError;
-    this.name = "SpinnerError";
+});
+Object.defineProperty(exports, 'list', {
+  enumerable: true,
+  get: function () {
+    return src_terminal_list_js.list;
   }
-};
-var spinner = async (options) => {
-  const handleError = (error) => {
-    const errorMessage = maskTokens(error.message);
-    note((0, import_yoctocolors6.redBright)(`${errorMessage}
-
-${error.stack}`));
-    throw new SpinnerError(errorMessage, error);
-  };
-  if (import_is_in_ci.default || !shouldPrint()) {
-    try {
-      return await options.task();
-    } catch (err) {
-      return handleError(err);
-    }
+});
+Object.defineProperty(exports, 'maskTokens', {
+  enumerable: true,
+  get: function () {
+    return src_logging_mask_tokens_js.maskTokens;
   }
-  const spinner2 = (0, import_yocto_spinner.default)({ stream: process.stdout }).start(options.startMessage);
-  try {
-    const result = await options.task(spinner2);
-    spinner2.success(options.stopMessage);
-    await new Promise((resolve) => process.nextTick(resolve));
-    return result;
-  } catch (err) {
-    spinner2.error((0, import_yoctocolors6.redBright)(`${options.startMessage} --> Error!`));
-    return handleError(err);
+});
+Object.defineProperty(exports, 'note', {
+  enumerable: true,
+  get: function () {
+    return src_terminal_note_js.note;
   }
-};
-
-// src/string.ts
-function capitalizeFirstLetter(val) {
-  return String(val).charAt(0).toUpperCase() + String(val).slice(1);
-}
-function camelCaseToWords(s) {
-  const result = s.replace(/([a-z])([A-Z])/g, "$1 $2");
-  const withSpaces = result.replace(/([A-Z])([a-z])/g, " $1$2");
-  const capitalized = capitalizeFirstLetter(withSpaces);
-  return capitalized.replace(/\s+/g, " ").trim();
-}
-
-// src/terminal/table.ts
-var import_console_table_printer = require("console-table-printer");
-var import_yoctocolors7 = require("yoctocolors");
-function table(title, data) {
-  if (!shouldPrint()) {
-    return;
+});
+Object.defineProperty(exports, 'outro', {
+  enumerable: true,
+  get: function () {
+    return src_terminal_outro_js.outro;
   }
-  note(title);
-  if (!data || data.length === 0) {
-    note("No data to display");
-    return;
+});
+Object.defineProperty(exports, 'spinner', {
+  enumerable: true,
+  get: function () {
+    return src_terminal_spinner_js.spinner;
   }
-  const columnKeys = Object.keys(data[0]);
-  const table2 = new import_console_table_printer.Table({
-    columns: columnKeys.map((key) => ({
-      name: key,
-      title: (0, import_yoctocolors7.whiteBright)(camelCaseToWords(key)),
-      alignment: "left"
-    }))
-  });
-  table2.addRows(data);
-  table2.printTable();
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CancelError,
-  CommandError,
-  SpinnerError,
-  ascii,
-  cancel,
-  executeCommand,
-  intro,
-  list,
-  maskTokens,
-  note,
-  outro,
-  spinner,
-  table
 });
-//# sourceMappingURL=terminal.cjs.map
+Object.defineProperty(exports, 'table', {
+  enumerable: true,
+  get: function () {
+    return src_terminal_table_js.table;
+  }
+});

package/dist/terminal.d.cts

@@ -1,219 +1,11 @@
-import { SpawnOptionsWithoutStdio } from 'node:child_process';
-import { Spinner } from 'yocto-spinner';
-
-/**
- * Prints the SettleMint ASCII art logo to the console in magenta color.
- * Used for CLI branding and visual identification.
- *
- * @example
- * import { ascii } from "@settlemint/sdk-utils/terminal";
- *
- * // Prints the SettleMint logo
- * ascii();
- */
-declare const ascii: () => void;
-
-/**
- * Error class used to indicate that the operation was cancelled.
- * This error is used to signal that the operation should be aborted.
- */
-declare class CancelError extends Error {
-}
-/**
- * Displays an error message in red inverse text and throws a CancelError.
- * Used to terminate execution with a visible error message.
- * Any sensitive tokens in the message are masked before display.
- *
- * @param msg - The error message to display
- * @returns never - Function does not return as it throws an error
- * @example
- * import { cancel } from "@settlemint/sdk-utils/terminal";
- *
- * // Exits process with error message
- * cancel("An error occurred");
- */
-declare const cancel: (msg: string) => never;
-
-/**
- * Options for executing a command, extending SpawnOptionsWithoutStdio
- */
-interface ExecuteCommandOptions extends SpawnOptionsWithoutStdio {
-    /** Whether to suppress output to stdout/stderr */
-    silent?: boolean;
-}
-/**
- * Error class for command execution errors
- * @extends Error
- */
-declare class CommandError extends Error {
-    readonly code: number;
-    readonly output: string[];
-    /**
-     * Constructs a new CommandError
-     * @param message - The error message
-     * @param code - The exit code of the command
-     * @param output - The output of the command
-     */
-    constructor(message: string, code: number, output: string[]);
-}
-/**
- * Executes a command with the given arguments in a child process.
- * Pipes stdin to the child process and captures stdout/stderr output.
- * Masks any sensitive tokens in the output before displaying or returning.
- *
- * @param command - The command to execute
- * @param args - Array of arguments to pass to the command
- * @param options - Options for customizing command execution
- * @returns Array of output strings from stdout and stderr
- * @throws {CommandError} If the process fails to start or exits with non-zero code
- * @example
- * import { executeCommand } from "@settlemint/sdk-utils/terminal";
- *
- * // Execute git clone
- * await executeCommand("git", ["clone", "repo-url"]);
- *
- * // Execute silently
- * await executeCommand("npm", ["install"], { silent: true });
- */
-declare function executeCommand(command: string, args: string[], options?: ExecuteCommandOptions): Promise<string[]>;
-
-/**
- * Displays an introductory message in magenta text with padding.
- * Any sensitive tokens in the message are masked before display.
- *
- * @param msg - The message to display as introduction
- * @example
- * import { intro } from "@settlemint/sdk-utils/terminal";
- *
- * // Display intro message
- * intro("Starting deployment...");
- */
-declare const intro: (msg: string) => void;
-
-/**
- * Displays a list of items in a formatted manner, supporting nested items.
- *
- * @param title - The title of the list
- * @param items - The items to display, can be strings or arrays for nested items
- * @returns The formatted list
- * @example
- * import { list } from "@settlemint/sdk-utils/terminal";
- *
- * // Simple list
- * list("Use cases", ["use case 1", "use case 2", "use case 3"]);
- *
- * // Nested list
- * list("Providers", [
- *   "AWS",
- *   ["us-east-1", "eu-west-1"],
- *   "Azure",
- *   ["eastus", "westeurope"]
- * ]);
- */
-declare function list(title: string, items: Array<string | string[]>): void;
-
-/**
- * Displays a note message with optional warning level formatting.
- * Regular notes are displayed in normal text, while warnings are shown in yellow.
- * Any sensitive tokens in the message are masked before display.
- *
- * @param message - The message to display as a note
- * @param level - The note level: "info" (default) or "warn" for warning styling
- * @example
- * import { note } from "@settlemint/sdk-utils/terminal";
- *
- * // Display info note
- * note("Operation completed successfully");
- *
- * // Display warning note
- * note("Low disk space remaining", "warn");
- */
-declare const note: (message: string, level?: "info" | "warn") => void;
-
-/**
- * Displays a closing message in green inverted text with padding.
- * Any sensitive tokens in the message are masked before display.
- *
- * @param msg - The message to display as conclusion
- * @example
- * import { outro } from "@settlemint/sdk-utils/terminal";
- *
- * // Display outro message
- * outro("Deployment completed successfully!");
- */
-declare const outro: (msg: string) => void;
-
-/**
- * Error class used to indicate that the spinner operation failed.
- * This error is used to signal that the operation should be aborted.
- */
-declare class SpinnerError extends Error {
-    readonly originalError: Error;
-    constructor(message: string, originalError: Error);
-}
-/**
- * Options for configuring the spinner behavior
- */
-interface SpinnerOptions<R> {
-    /** Message to display when spinner starts */
-    startMessage: string;
-    /** Async task to execute while spinner is active */
-    task: (spinner?: Spinner) => Promise<R>;
-    /** Message to display when spinner completes successfully */
-    stopMessage: string;
-}
-/**
- * Displays a loading spinner while executing an async task.
- * Shows progress with start/stop messages and handles errors.
- * Spinner is disabled in CI environments.
- *
- * @param options - Configuration options for the spinner
- * @returns The result from the executed task
- * @throws Will exit process with code 1 if task fails
- * @example
- * import { spinner } from "@settlemint/sdk-utils/terminal";
- *
- * // Show spinner during async task
- * const result = await spinner({
- *   startMessage: "Deploying...",
- *   task: async () => {
- *     // Async work here
- *     return "success";
- *   },
- *   stopMessage: "Deployed successfully!"
- * });
- */
-declare const spinner: <R>(options: SpinnerOptions<R>) => Promise<R>;
-
-/**
- * Displays data in a formatted table in the terminal.
- *
- * @param title - Title to display above the table
- * @param data - Array of objects to display in table format
- * @example
- * import { table } from "@settlemint/sdk-utils/terminal";
- *
- * const data = [
- *   { name: "Item 1", value: 100 },
- *   { name: "Item 2", value: 200 }
- * ];
- *
- * table("My Table", data);
- */
-declare function table(title: string, data: unknown[]): void;
-
-/**
- * Masks sensitive SettleMint tokens in output text by replacing them with asterisks.
- * Handles personal access tokens (PAT), application access tokens (AAT), and service account tokens (SAT).
- *
- * @param output - The text string that may contain sensitive tokens
- * @returns The text with any sensitive tokens masked with asterisks
- * @example
- * import { maskTokens } from "@settlemint/sdk-utils/terminal";
- *
- * // Masks a token in text
- * const masked = maskTokens("Token: sm_pat_****"); // "Token: ***"
- */
-declare const maskTokens: (output: string) => string;
-
-export { CancelError, CommandError, type ExecuteCommandOptions, SpinnerError, type SpinnerOptions, ascii, cancel, executeCommand, intro, list, maskTokens, note, outro, spinner, table };
+import { ascii } from "./terminal/ascii.js";
+import { CancelError, cancel } from "./terminal/cancel.js";
+import { CommandError, ExecuteCommandOptions, executeCommand } from "./terminal/execute-command.js";
+import { intro } from "./terminal/intro.js";
+import { list } from "./terminal/list.js";
+import { note } from "./terminal/note.js";
+import { outro } from "./terminal/outro.js";
+import { SpinnerError, SpinnerOptions, spinner } from "./terminal/spinner.js";
+import { table } from "./terminal/table.js";
+import { maskTokens } from "./logging/mask-tokens.js";
+export { CancelError, CommandError, ExecuteCommandOptions, SpinnerError, SpinnerOptions, ascii, cancel, executeCommand, intro, list, maskTokens, note, outro, spinner, table };