@visulima/cerebro 3.0.0-alpha.9 → 3.0.1

package/dist/packem_shared/VERBOSITY_QUIET-Dp46zlLW.js

@@ -1,10 +0,0 @@
-const OUTPUT_NORMAL = 1;
-const OUTPUT_RAW = 2;
-const OUTPUT_PLAIN = 4;
-const VERBOSITY_QUIET = 16;
-const VERBOSITY_NORMAL = 32;
-const VERBOSITY_VERBOSE = 64;
-const VERBOSITY_DEBUG = 128;
-const POSITIONALS_KEY = "positionals";
-
-export { OUTPUT_NORMAL, OUTPUT_PLAIN, OUTPUT_RAW, POSITIONALS_KEY, VERBOSITY_DEBUG, VERBOSITY_NORMAL, VERBOSITY_QUIET, VERBOSITY_VERBOSE };

package/dist/packem_shared/VisulimaError-DA7QsCxH.js

@@ -1,34 +0,0 @@
-const isVisulimaError = (error) => error instanceof Error && error.type === "VisulimaError";
-class VisulimaError extends Error {
-  loc;
-  title;
-  /**
-   * A message that explains to the user how they can fix the error.
-   */
-  hint;
-  type = "VisulimaError";
-  constructor({ cause, hint, location, message, name, stack, title }) {
-    super(message, {
-      cause
-    });
-    this.title = title;
-    this.name = name;
-    this.stack = stack ?? this.stack;
-    this.loc = location;
-    this.hint = hint;
-  }
-  setLocation(location) {
-    this.loc = location;
-  }
-  setName(name) {
-    this.name = name;
-  }
-  setMessage(message) {
-    this.message = message;
-  }
-  setHint(hint) {
-    this.hint = hint;
-  }
-}
-
-export { VisulimaError, isVisulimaError };

package/dist/packem_shared/cerebro-error-GmJ3jN7Q.js

@@ -1,16 +0,0 @@
-import { VisulimaError } from './VisulimaError-DA7QsCxH.js';
-
-class CerebroError extends VisulimaError {
-  code;
-  context;
-  constructor(message, code, context) {
-    super({
-      message,
-      name: "CerebroError"
-    });
-    this.code = code;
-    this.context = context;
-  }
-}
-
-export { CerebroError as C };

package/dist/packem_shared/help-command-BY7rQUvM.js

@@ -1,249 +0,0 @@
-import { inverse, cyan, green, yellow } from '@visulima/colorize';
-import { t as templateFormat, c as commandLineUsage } from './index-C2-8b3A4.js';
-
-const defaultEnv = [
-  {
-    defaultValue: "32",
-    description: "Controls the verbosity level of output. Valid values: '16' (quiet), '32' (normal), '64' (verbose), '128' (debug)",
-    name: "CEREBRO_OUTPUT_LEVEL",
-    type: String
-  },
-  {
-    description: "Sets the minimum required Node.js version. Overrides the default minimum version check",
-    name: "CEREBRO_MIN_NODE_VERSION",
-    type: Number
-  },
-  {
-    defaultValue: false,
-    description: "When set, disables the update notifier check",
-    name: "NO_UPDATE_NOTIFIER",
-    type: Boolean
-  },
-  {
-    description: "Standard Node.js environment variable. When set to 'test', disables update notifier",
-    name: "NODE_ENV",
-    type: String
-  },
-  {
-    defaultValue: false,
-    description: "When set, enables debug output (same as --debug flag)",
-    name: "DEBUG",
-    type: Boolean
-  },
-  {
-    description: "Sets the terminal width for table rendering. Useful for testing and consistent output",
-    name: "CEREBRO_TERMINAL_WIDTH",
-    type: Number
-  }
-];
-
-const defaultOptions = [
-  {
-    description: "Turn on verbose output",
-    group: "global",
-    name: "verbose",
-    type: Boolean
-  },
-  {
-    description: "Turn on debugging output",
-    group: "global",
-    name: "debug",
-    type: Boolean
-  },
-  {
-    alias: "h",
-    description: "Print out helpful usage information",
-    group: "global",
-    name: "help",
-    type: Boolean
-  },
-  {
-    alias: "q",
-    description: "Silence output",
-    group: "global",
-    name: "quiet",
-    type: Boolean
-  },
-  {
-    alias: "V",
-    description: "Print version info",
-    group: "global",
-    name: "version",
-    type: Boolean
-  },
-  {
-    description: "Turn off colored output",
-    group: "global",
-    name: "no-color",
-    type: Boolean
-  },
-  {
-    description: "Force colored output",
-    group: "global",
-    name: "color",
-    type: Boolean
-  }
-];
-
-const EMPTY_GROUP_KEY = "__Other";
-const upperFirstChar = (string_) => string_.charAt(0).toUpperCase() + string_.slice(1);
-const printGeneralHelp = (logger, runtime, commands, groupOption) => {
-  logger.debug("no command given, printing general help...");
-  let filteredCommands = [...new Set(commands.values())].filter((command) => !command.hidden);
-  if (groupOption) {
-    filteredCommands = filteredCommands.filter((command) => command.group === groupOption);
-  }
-  const groupedCommands = filteredCommands.reduce((accumulator, command) => {
-    const group = command.group ?? EMPTY_GROUP_KEY;
-    if (!accumulator[group]) {
-      accumulator[group] = [];
-    }
-    accumulator[group].push(command);
-    return accumulator;
-  }, {});
-  const buildCommandList = (commandList) => commandList.map((command) => {
-    let aliases = "";
-    if (typeof command.alias === "string") {
-      aliases = command.alias;
-    } else if (Array.isArray(command.alias)) {
-      aliases = command.alias.join(", ");
-    }
-    if (aliases !== "") {
-      aliases = ` [${aliases}]`;
-    }
-    let commandDisplay = command.name;
-    if (command.commandPath && command.commandPath.length > 0) {
-      commandDisplay = `${command.commandPath.join(" ")} ${command.name}`;
-    }
-    return [`${green(commandDisplay)}${aliases}`, command.description ?? ""];
-  });
-  (logger?.raw ?? logger.log)(
-    commandLineUsage(
-      [
-        {
-          content: `${cyan(runtime.getCliName())} ${green("<command>")} [positional arguments] ${yellow("[options]")}`,
-          header: inverse.cyan(" Usage ")
-        },
-        ...Object.keys(groupedCommands).map((key) => {
-          const groupOptionName = groupOption ? ` ${upperFirstChar(groupOption)}` : "";
-          return {
-            content: buildCommandList(groupedCommands[key]),
-            header: key === EMPTY_GROUP_KEY || groupOption ? inverse.green(` Available${groupOptionName} Commands `) : ` ${inverse.green(` ${upperFirstChar(key)} `)}`
-          };
-        }),
-        commands.has("help") ? {
-          header: inverse.yellow(" Command Options "),
-          optionList: commands.get("help").options?.filter((option) => !option.hidden)
-        } : void 0,
-        { header: inverse.yellow(" Global Options "), optionList: defaultOptions },
-        {
-          content: defaultEnv.filter((envVariable) => !envVariable.hidden).map((envVariable) => [envVariable.name, envVariable.description ?? ""]),
-          header: inverse.magenta(" Environment Variables ")
-        },
-        {
-          content: `Run "${cyan(runtime.getCliName())} ${green("help <command>")}" or "${cyan(runtime.getCliName())} ${green("<command>")} ${yellow("--help")}" for help with a specific command.`,
-          raw: true
-        }
-      ].filter(Boolean)
-    )
-  );
-};
-const printCommandHelp = (logger, runtime, commands, name) => {
-  let command = commands.get(name);
-  if (!command) {
-    for (const cmd of commands.values()) {
-      const fullPath = cmd.commandPath ? [...cmd.commandPath, cmd.name] : [cmd.name];
-      if (fullPath[fullPath.length - 1] === name || fullPath.join(" ") === name) {
-        command = cmd;
-        break;
-      }
-    }
-  }
-  if (!command) {
-    logger.error(`Command "${name}" not found`);
-    return;
-  }
-  const usageGroups = [];
-  const fullCommandPath = command.commandPath ? [...command.commandPath, command.name] : [command.name];
-  const commandDisplay = fullCommandPath.join(" ");
-  usageGroups.push({
-    content: `${cyan(runtime.getCliName())} ${green(commandDisplay)}${command.argument ? " [positional arguments]" : ""}${command.options ? " [options]" : ""}`,
-    header: inverse.cyan(" Usage ")
-  });
-  if (command.description) {
-    usageGroups.push({ content: command.description, header: inverse.green(" Description ") });
-  }
-  if (command.argument) {
-    usageGroups.push({ header: "Command Positional Arguments", isArgument: true, optionList: [command.argument] });
-  }
-  if (Array.isArray(command.options) && command.options.length > 0) {
-    usageGroups.push({
-      header: inverse.yellow(" Command Options "),
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      optionList: command.options.filter((option) => !option.hidden)
-    });
-  }
-  usageGroups.push({ header: inverse.yellow(" Global Options "), optionList: defaultOptions });
-  if (Array.isArray(command.env) && command.env.length > 0) {
-    const visibleEnvVariables = command.env.filter((envVariable) => !envVariable.hidden);
-    if (visibleEnvVariables.length > 0) {
-      usageGroups.push({
-        content: visibleEnvVariables.map((envVariable) => [envVariable.name, envVariable.description ?? ""]),
-        header: inverse.magenta(" Environment Variables ")
-      });
-    }
-  }
-  if (command.alias !== void 0 && command.alias.length > 0) {
-    let alias = command.alias;
-    if (typeof command.alias === "string") {
-      alias = [command.alias];
-    }
-    usageGroups.splice(1, 0, {
-      content: alias,
-      header: "Alias(es)"
-    });
-  }
-  if (Array.isArray(command.examples) && command.examples.length > 0) {
-    usageGroups.push({
-      content: command.examples,
-      header: "Examples"
-    });
-  }
-  (logger?.raw ?? logger.log)(commandLineUsage(usageGroups));
-};
-class HelpCommand {
-  name = "help";
-  options = [
-    {
-      description: "Display only the specified group",
-      name: "group",
-      type: String
-    }
-  ];
-  commands;
-  constructor(commands) {
-    this.commands = commands;
-  }
-  execute(toolbox) {
-    const { commandName, logger, options, runtime } = toolbox;
-    const { footer, header } = runtime.getCommandSection();
-    if (header) {
-      (logger?.raw ?? logger.log)(templateFormat(header));
-    }
-    if (commandName === "help") {
-      printGeneralHelp(
-        logger,
-        runtime,
-        this.commands,
-        typeof options?.group === "string" ? options.group : void 0
-      );
-    } else {
-      printCommandHelp(logger, runtime, this.commands, commandName);
-    }
-    if (footer) {
-      (logger?.raw ?? logger.log)(templateFormat(footer));
-    }
-  }
-}
-
-export { HelpCommand as H, defaultOptions as d };

package/dist/packem_shared/index-C2-8b3A4.js

@@ -1,259 +0,0 @@
-import { createRequire as __cjs_createRequire } from "node:module";
-
-const __cjs_require = __cjs_createRequire(import.meta.url);
-
-const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
-
-const __cjs_getBuiltinModule = (module) => {
-    // Check if we're in Node.js and version supports getBuiltinModule
-    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
-        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
-        // Node.js 20.16.0+ and 22.3.0+
-        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
-            return __cjs_getProcess.getBuiltinModule(module);
-        }
-    }
-    // Fallback to createRequire
-    return __cjs_require(module);
-};
-
-import { createTable } from '@visulima/tabular';
-import { NO_BORDER } from '@visulima/tabular/style';
-import colorizeTemplate from '@visulima/colorize/template';
-import { d as getEnv } from './runtime-process-B6ZplyWn.js';
-const os = __cjs_getBuiltinModule("node:os");
-import { bold } from '@visulima/colorize';
-
-const formatCache = /* @__PURE__ */ new Map();
-const MAX_CACHE_SIZE = 500;
-const templateFormat = (string_) => {
-  if (!string_) {
-    return "";
-  }
-  if (string_ === "") {
-    return "";
-  }
-  const cached = formatCache.get(string_);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const result = colorizeTemplate(Object.assign([], { raw: [string_] }));
-  if (formatCache.size >= MAX_CACHE_SIZE) {
-    const firstKey = formatCache.keys().next().value;
-    if (firstKey !== void 0) {
-      formatCache.delete(firstKey);
-    }
-  }
-  formatCache.set(string_, result);
-  return result;
-};
-
-const getTerminalWidth = () => {
-  const env = getEnv();
-  const terminalWidth = env.CEREBRO_TERMINAL_WIDTH;
-  if (terminalWidth === void 0) {
-    return void 0;
-  }
-  const parsed = Number.parseInt(terminalWidth, 10);
-  if (Number.isNaN(parsed) || parsed <= 0) {
-    return void 0;
-  }
-  return parsed;
-};
-
-class BaseSection {
-  lines;
-  constructor() {
-    this.lines = [];
-  }
-  add(line) {
-    this.lines.push(line);
-  }
-  toString() {
-    return this.lines.join(os.EOL);
-  }
-  header(text) {
-    this.add(bold(text));
-    this.lines.push("");
-  }
-}
-
-class ContentSection extends BaseSection {
-  constructor(section) {
-    super();
-    if (section.header) {
-      this.header(templateFormat(section.header));
-    }
-    if (section.content) {
-      if (section.raw) {
-        if (Array.isArray(section.content) && section.content.every((value) => typeof value === "string")) {
-          section.content.forEach((row) => {
-            if (Array.isArray(row)) {
-              row.forEach((cell) => this.add(templateFormat(cell)));
-            } else {
-              this.add(templateFormat(row));
-            }
-          });
-        } else if (typeof section.content === "string") {
-          this.add(templateFormat(section.content));
-        } else {
-          throw new TypeError("Invalid raw content, must be a string or array of strings.");
-        }
-      } else {
-        this.add(this.getContentLines(section.content));
-      }
-      this.add("");
-    }
-  }
-  // eslint-disable-next-line class-methods-use-this
-  getContentLines(content) {
-    if (typeof content === "string") {
-      const table = createTable({
-        showHeader: false,
-        style: {
-          border: NO_BORDER,
-          paddingLeft: 4,
-          paddingRight: 1
-        },
-        terminalWidth: getTerminalWidth(),
-        truncateOverflow: false,
-        wordWrap: true
-      });
-      table.addRow([templateFormat(content)]);
-      return table.toString();
-    }
-    if (Array.isArray(content) && content.every((value) => typeof value === "string" || Array.isArray(value) && value.every((value2) => typeof value2 === "string"))) {
-      const table = createTable({
-        showHeader: false,
-        style: {
-          border: NO_BORDER,
-          paddingLeft: 4,
-          paddingRight: 1
-        },
-        terminalWidth: getTerminalWidth(),
-        truncateOverflow: false,
-        wordWrap: true
-      });
-      content.forEach((row) => {
-        if (Array.isArray(row)) {
-          table.addRow(row.map((cell) => templateFormat(cell)));
-        } else {
-          table.addRow([templateFormat(row)]);
-        }
-      });
-      return table.toString();
-    }
-    if (typeof content === "object") {
-      const contentObject = content;
-      if (!contentObject.options || !contentObject.data) {
-        throw new Error(`Must have an "options" or "data" property
-${JSON.stringify(content)}`);
-      }
-      const table = createTable({
-        showHeader: false,
-        style: {
-          border: NO_BORDER,
-          paddingLeft: 4,
-          paddingRight: 1
-        },
-        terminalWidth: getTerminalWidth(),
-        truncateOverflow: false,
-        wordWrap: true
-      });
-      contentObject.data.forEach((row) => {
-        if (Array.isArray(row)) {
-          table.addRow(row.map((cell) => templateFormat(cell)));
-        } else {
-          table.addRow([templateFormat(row)]);
-        }
-      });
-      return table.toString();
-    }
-    throw new Error(`invalid input - 'content' must be a string, array of strings or a object:
-
-${JSON.stringify(content)}`);
-  }
-}
-
-class OptionListSection extends BaseSection {
-  constructor(data) {
-    super();
-    let definitions = data.optionList ?? [];
-    const hide = Array.isArray(data.hide) ? data.hide : [data.hide].filter(Boolean);
-    const groups = Array.isArray(data.group) ? data.group : [data.group].filter(Boolean);
-    if (hide.length > 0) {
-      definitions = definitions.filter((definition) => !hide.includes(definition.name));
-    }
-    if (data.header) {
-      this.header(templateFormat(data.header));
-    }
-    if (groups.length > 0) {
-      definitions = definitions.filter((definition) => {
-        const noGroupMatch = groups.includes("_none") && !definition.group;
-        const groupMatch = this.intersect(Array.isArray(definition.group) ? definition.group : [definition.group], groups);
-        return noGroupMatch || groupMatch ? definition : void 0;
-      });
-    }
-    const table = createTable({
-      showHeader: false,
-      style: {
-        border: NO_BORDER,
-        paddingLeft: 2,
-        paddingRight: 1,
-        ...data.tableOptions?.style
-      },
-      terminalWidth: getTerminalWidth() ?? data.tableOptions?.terminalWidth,
-      truncateOverflow: false,
-      wordWrap: data.tableOptions?.wordWrap ?? true,
-      ...data.tableOptions
-    });
-    definitions.forEach(
-      (definition) => table.addRow([this.getOptionNames(definition, data.reverseNameOrder ?? false, data.isArgument ?? false), templateFormat(definition.description)])
-    );
-    this.add(table.toString());
-    this.lines.push("");
-  }
-  // eslint-disable-next-line class-methods-use-this,sonarjs/cognitive-complexity,@typescript-eslint/no-explicit-any
-  getOptionNames(definition, reverseNameOrder, isArgument) {
-    if (!definition.name) {
-      throw new TypeError("Invalid option definition, name is required.");
-    }
-    let type = definition.type ? definition.type.name.toLowerCase() : "string";
-    const multiple = definition.multiple || definition.lazyMultiple ? "[]" : "";
-    type = templateFormat(definition.typeLabel ?? `{underline ${type}${multiple}}`);
-    let result;
-    if (definition.alias) {
-      if (definition.name) {
-        const name = isArgument ? definition.name : `{yellow --${definition.name}}`;
-        result = reverseNameOrder ? templateFormat(`{bold ${name}}, {bold -${definition.alias}} ${type}`) : templateFormat(`{bold -${definition.alias}}, {bold ${name}} ${type}`);
-      } else if (reverseNameOrder) {
-        result = templateFormat(`{bold -${definition.alias}} ${type}`);
-      } else {
-        result = templateFormat(`{bold -${definition.alias}} ${type}`);
-      }
-    } else {
-      result = templateFormat(`{bold ${isArgument ? definition.name : `{yellow --${definition.name}}`}} ${type}`);
-    }
-    return result;
-  }
-  // eslint-disable-next-line class-methods-use-this
-  intersect(array1, array2) {
-    return array1.some((item1) => array2.includes(item1));
-  }
-}
-
-const commandLineUsage = (sections) => {
-  const lines = Array.isArray(sections) ? sections : [sections];
-  if (lines.length === 0) {
-    return "";
-  }
-  return `
-${sections.map((section) => {
-    if (section.optionList) {
-      return new OptionListSection(section).toString();
-    }
-    return new ContentSection(section).toString();
-  }).join("\n")}`;
-};
-
-export { commandLineUsage as c, templateFormat as t };