@visulima/cerebro 2.1.5 → 3.0.0-alpha.10

package/dist/packem_shared/VERBOSITY_QUIET-Dp46zlLW.js

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,16 @@
+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/index-CS31xKFe.js

@@ -0,0 +1,264 @@
+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((item) => typeof item === "string");
+    const groups = Array.isArray(data.group) ? data.group : [data.group].filter((item) => typeof item === "string");
+    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 typedDefinition = definition;
+        const noGroupMatch = groups.includes("_none") && !typedDefinition.group;
+        const definitionGroup = typedDefinition.group;
+        const groupMatch = this.intersect(Array.isArray(definitionGroup) ? definitionGroup : [definitionGroup], 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) => {
+      const typedDefinition = definition;
+      table.addRow([this.getOptionNames(typedDefinition, data.reverseNameOrder ?? false, data.isArgument ?? false), templateFormat(typedDefinition.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 };

package/dist/packem_shared/runtime-process-B6ZplyWn.js

@@ -0,0 +1,187 @@
+const hasDeno = (global) => "Deno" in global;
+const hasBun = (global) => "Bun" in global;
+const getArgv = () => {
+  if (hasDeno(globalThis)) {
+    const deno = globalThis.Deno;
+    const execPath = deno.execPath();
+    let scriptPath = execPath;
+    try {
+      const { importMeta } = globalThis;
+      if (importMeta?.url) {
+        scriptPath = importMeta.url;
+      }
+    } catch {
+    }
+    return [execPath, scriptPath, ...deno.args];
+  }
+  if (hasBun(globalThis)) {
+    const bun = globalThis.Bun;
+    return bun.process.argv;
+  }
+  return process.argv;
+};
+const getCwd = () => {
+  if (hasDeno(globalThis)) {
+    const deno = globalThis.Deno;
+    return deno.cwd();
+  }
+  if (hasBun(globalThis)) {
+    const bun = globalThis.Bun;
+    return bun.process.cwd();
+  }
+  return process.cwd();
+};
+const getEnv = () => {
+  if (hasDeno(globalThis)) {
+    const deno = globalThis.Deno;
+    return /* @__PURE__ */ new Proxy(deno.env.toObject(), {
+      get: (target, prop) => {
+        if (typeof prop === "string") {
+          return deno.env.get(prop);
+        }
+        return target[prop];
+      },
+      has: (target, prop) => {
+        if (typeof prop === "string") {
+          return deno.env.has(prop);
+        }
+        return prop in target;
+      },
+      set: (_target, prop, value) => {
+        if (typeof prop === "string") {
+          if (value === void 0) {
+            return true;
+          }
+          deno.env.set(prop, value);
+          return true;
+        }
+        return false;
+      }
+    });
+  }
+  if (hasBun(globalThis)) {
+    const bun = globalThis.Bun;
+    return bun.process.env;
+  }
+  return process.env;
+};
+const getExecArgv = () => {
+  if (hasDeno(globalThis)) {
+    return [];
+  }
+  if (hasBun(globalThis)) {
+    const bun = globalThis.Bun;
+    return bun.process.execArgv;
+  }
+  return process.execArgv;
+};
+const getExecPath = () => {
+  if (hasDeno(globalThis)) {
+    const deno = globalThis.Deno;
+    return deno.execPath();
+  }
+  if (hasBun(globalThis)) {
+    const bun = globalThis.Bun;
+    return bun.process.execPath;
+  }
+  return process.execPath;
+};
+const getPlatform = () => {
+  if (hasDeno(globalThis)) {
+    const deno = globalThis.Deno;
+    const os = deno.build?.os ?? "unknown";
+    return os === "windows" ? "win32" : os;
+  }
+  if (hasBun(globalThis)) {
+    const bun = globalThis.Bun;
+    return bun.platform ?? "unknown";
+  }
+  return process.platform;
+};
+const getArch = () => {
+  if (hasDeno(globalThis)) {
+    const deno = globalThis.Deno;
+    const arch = deno.build?.arch ?? "unknown";
+    if (arch === "x86_64") {
+      return "x64";
+    }
+    if (arch === "aarch64") {
+      return "arm64";
+    }
+    return arch;
+  }
+  if (hasBun(globalThis)) {
+    const bun = globalThis.Bun;
+    return bun.process.arch;
+  }
+  return process.arch;
+};
+const getVersions = () => {
+  if (hasDeno(globalThis)) {
+    const deno = globalThis.Deno;
+    const versions = {};
+    if (deno.version?.deno) {
+      versions.deno = deno.version.deno;
+    }
+    if (deno.version?.v8) {
+      versions.v8 = deno.version.v8;
+    }
+    if (deno.version?.typescript) {
+      versions.typescript = deno.version.typescript;
+    }
+    return versions;
+  }
+  if (hasBun(globalThis)) {
+    const bun = globalThis.Bun;
+    const versions = { ...bun.process.versions };
+    if (bun.version) {
+      versions.bun = bun.version;
+    }
+    return versions;
+  }
+  return process.versions;
+};
+const exitProcess = (exitCode = 0) => {
+  if (hasDeno(globalThis)) {
+    const deno = globalThis.Deno;
+    deno.exit(exitCode);
+    throw new Error("Deno exit failed");
+  }
+  if (hasBun(globalThis)) {
+    const bun = globalThis.Bun;
+    bun.process.exit(exitCode);
+    throw new Error("Bun exit failed");
+  }
+  const nodeProcess = process;
+  nodeProcess.exit(exitCode);
+  return void 0;
+};
+const onProcessEvent = (event, handler) => {
+  if (hasDeno(globalThis)) {
+    return () => {
+    };
+  }
+  if (hasBun(globalThis)) {
+    try {
+      const bun = globalThis.Bun;
+      if (bun.process?.on) {
+        bun.process.on(event, handler);
+        return () => {
+          if (bun.process?.removeListener) {
+            bun.process.removeListener(event, handler);
+          }
+        };
+      }
+    } catch {
+    }
+    return () => {
+    };
+  }
+  const nodeProcess = process;
+  nodeProcess.on(event, handler);
+  return () => {
+    nodeProcess.removeListener(event, handler);
+  };
+};
+
+export { getVersions as a, getPlatform as b, getArch as c, getEnv as d, exitProcess as e, getArgv as f, getCwd as g, getExecPath as h, getExecArgv as i, onProcessEvent as o };