@visulima/cerebro 3.0.0-alpha.10 → 3.0.0-alpha.12

package/dist/packem_shared/{Cerebro-bgCm5Tb1.js → Cerebro-f9jDcQQy.js}

@@ -17,7 +17,6 @@ const __cjs_getBuiltinModule = (module) => {
     return __cjs_require(module);
 };
 
-import HelpCommand from '../commands/help-command.js';
 import { VERBOSITY_DEBUG, POSITIONALS_KEY, VERBOSITY_QUIET, VERBOSITY_VERBOSE, VERBOSITY_NORMAL } from './VERBOSITY_QUIET-Dp46zlLW.js';
 import { C as CerebroError } from './cerebro-error-GmJ3jN7Q.js';
 import { d as getEnv, f as getArgv, o as onProcessEvent, e as exitProcess, g as getCwd, h as getExecPath, i as getExecArgv } from './runtime-process-B6ZplyWn.js';
@@ -1126,12 +1125,26 @@ class EmptyToolbox {
   env;
   logger;
   runtime;
+  rawUnknown;
   constructor(commandName, command) {
     this.commandName = commandName;
     this.command = command;
   }
 }
 
+class CommandLoaderError extends CerebroError {
+  commandName;
+  constructor(commandName, reason, cause) {
+    super(`Failed to load command "${commandName}": ${reason}`, "COMMAND_LOADER_ERROR", { commandName, reason });
+    this.name = "CommandLoaderError";
+    this.commandName = commandName;
+    this.hint = `Ensure the loader resolves to a module with a default export that is the command handler function.`;
+    if (cause !== void 0) {
+      this.cause = cause;
+    }
+  }
+}
+
 const argumentNameRegExp = /^-{1,2}(\w+)(=(.+))?$/;
 const getParameterOption = (argument, options, optionMapByName, optionMapByAlias) => {
   const regExpResult = argumentNameRegExp.exec(argument);
@@ -1284,15 +1297,36 @@ const buildOptionMaps = (commandOptions) => {
   }
   return { optionMapByAlias, optionMapByName };
 };
+const loadLazyHandler = async (command) => {
+  if (typeof command.__resolvedExecute__ === "function") {
+    return command.__resolvedExecute__;
+  }
+  if (typeof command.loader !== "function") {
+    throw new CommandLoaderError(command.name, "no execute or loader defined");
+  }
+  let loadedModule;
+  try {
+    loadedModule = await command.loader();
+  } catch (error) {
+    throw new CommandLoaderError(command.name, error instanceof Error ? error.message : String(error), error);
+  }
+  const handler = loadedModule.default;
+  if (typeof handler !== "function") {
+    throw new CommandLoaderError(command.name, "loader did not return a module with a default-exported handler function");
+  }
+  command.__resolvedExecute__ = handler;
+  return handler;
+};
 const prepareToolbox = (command, parsedArgs, booleanValues, extraOptions) => {
   const toolbox = new EmptyToolbox(command.name, command);
-  const { _all, positionals } = parsedArgs;
+  const { _all, _unknown, positionals } = parsedArgs;
   const hasBooleanValues = Object.keys(booleanValues).length > 0;
   const mergedAll = hasBooleanValues ? { ..._all, ...booleanValues } : _all;
   if (POSITIONALS_KEY in mergedAll) {
     delete mergedAll[POSITIONALS_KEY];
   }
   toolbox.argument = positionals?.[POSITIONALS_KEY] ?? [];
+  toolbox.rawUnknown = [..._unknown ?? []];
   const hasExtraOptions = Object.keys(extraOptions).length > 0;
   toolbox.options = hasExtraOptions ? { ...mergedAll, ...extraOptions } : mergedAll;
   toolbox.env = processEnvVariables(command.env);
@@ -1341,7 +1375,13 @@ const processCommandArgs = (command, commandArguments, defaultOptions) => {
   });
   return { arguments_, booleanValues, parsedArgs };
 };
-const executeCommand = async (command, toolbox, _commandArgs) => command.execute(toolbox);
+const executeCommand = async (command, toolbox, _commandArgs) => {
+  if (typeof command.execute === "function") {
+    return command.execute(toolbox);
+  }
+  const handler = await loadLazyHandler(command);
+  return handler(toolbox);
+};
 
 class CommandValidationError extends CerebroError {
   commandName;
@@ -2820,7 +2860,10 @@ class Cli {
     this.#logger.debug(`command '${pathKey}' found, parsing command args: ${commandArguments.join(", ")}`);
     const { arguments_, booleanValues, parsedArgs } = processCommandArgs(command, commandArguments, this.#getAllGlobalOptions());
     const hasBooleanValues = Object.keys(booleanValues).length > 0;
-    const commandArgs = hasBooleanValues ? { ...parsedArgs, _all: { ...parsedArgs._all, ...booleanValues } } : parsedArgs;
+    let commandArgs = parsedArgs;
+    if (hasBooleanValues) {
+      commandArgs = { ...parsedArgs, _all: { ...parsedArgs._all, ...booleanValues } };
+    }
     validateRequiredOptions(arguments_, commandArgs, command);
     const toolbox = prepareToolbox(command, parsedArgs, booleanValues, extraOptions);
     toolbox.runtime = this;
@@ -3004,6 +3047,22 @@ class Cli {
   addCommand(command) {
     validateObject(command, "Command");
     validateCommandName(command.name);
+    const hasExecute = typeof command.execute === "function";
+    const hasLoader = typeof command.loader === "function";
+    if (hasExecute && hasLoader) {
+      throw new CerebroError(
+        `Command "${command.name}" cannot define both "execute" and "loader" — choose one`,
+        "INVALID_COMMAND",
+        { commandName: command.name }
+      );
+    }
+    if (!hasExecute && !hasLoader) {
+      throw new CerebroError(
+        `Command "${command.name}" must define either "execute" or "loader"`,
+        "INVALID_COMMAND",
+        { commandName: command.name }
+      );
+    }
     if (command.alias) {
       if (typeof command.alias === "string") {
         validateCommandName(command.alias);
@@ -3102,7 +3161,9 @@ class Cli {
     }
     const existingNames = new Set(this.#customGlobalOptions.map((o) => o.name));
     if (existingNames.has(optionDefinition.name)) {
-      throw new CerebroError(`Global option "--${optionDefinition.name}" has already been added`, "DUPLICATE_OPTION", { optionName: optionDefinition.name });
+      throw new CerebroError(`Global option "--${optionDefinition.name}" has already been added`, "DUPLICATE_OPTION", {
+        optionName: optionDefinition.name
+      });
     }
     optionDefinition.group = "global";
     mapOptionTypeLabel(optionDefinition);
@@ -3233,6 +3294,7 @@ class Cli {
   async run(extraOptions = {}) {
     const { autoDispose = true, shouldExitProcess = true, ...otherExtraOptions } = extraOptions;
     if (!this.#commands.has("help")) {
+      const { default: HelpCommand } = await import('../commands/help-command.js');
       this.addCommand(new HelpCommand(this.#commands));
     }
     const commandNames = this.#getCommandNames();
@@ -3314,7 +3376,7 @@ class Cli {
         throw new CommandNotFoundError(pathKey, alternatives);
       }
     }
-    if (typeof command.execute !== "function") {
+    if (typeof command.execute !== "function" && typeof command.loader !== "function") {
       this.#logger.error(`Command "${command.name}" has no function to execute.`);
       return shouldExitProcess ? exitProcess(1) : void 0;
     }
@@ -3396,7 +3458,7 @@ class Cli {
       const alternatives = findAlternatives(pathKey || commandName, allCommandPaths);
       throw new CommandNotFoundError(commandName, alternatives);
     }
-    if (typeof command.execute !== "function") {
+    if (typeof command.execute !== "function" && typeof command.loader !== "function") {
       throw new CerebroError(`Command "${command.name}" has no function to execute`, "INVALID_COMMAND", { commandName: command.name });
     }
     const sanitizedArgv = sanitizeArguments(providedArgv);

package/dist/packem_shared/{index-CS31xKFe.js → index--1UArng3.js}

@@ -213,7 +213,10 @@ class OptionListSection extends BaseSection {
     });
     definitions.forEach((definition) => {
       const typedDefinition = definition;
-      table.addRow([this.getOptionNames(typedDefinition, data.reverseNameOrder ?? false, data.isArgument ?? false), templateFormat(typedDefinition.description)]);
+      table.addRow([
+        this.getOptionNames(typedDefinition, data.reverseNameOrder ?? false, data.isArgument ?? false),
+        templateFormat(typedDefinition.description)
+      ]);
     });
     this.add(table.toString());
     this.lines.push("");

package/dist/packem_shared/index.d-Br8HpP0A.d.ts

@@ -0,0 +1,93 @@
+type ColorizeMethod = (value: string) => string;
+type CodeFrameOptions = {
+  color?: {
+    gutter?: ColorizeMethod;
+    marker?: ColorizeMethod;
+    message?: ColorizeMethod;
+  };
+  linesAbove?: number;
+  linesBelow?: number;
+  message?: string;
+  prefix?: string;
+  showGutter?: boolean;
+  showLineNumbers?: boolean;
+  tabWidth?: number | false;
+};
+interface ErrorProperties {
+  cause?: unknown;
+  hint?: ErrorHint;
+  location?: ErrorLocation;
+  message?: string;
+  name: string;
+  stack?: string;
+  title?: string;
+}
+interface ErrorLocation {
+  column?: number;
+  file?: string;
+  line?: number;
+}
+/**
+* A message that explains to the user how they can fix the error.
+* @example
+* ```ts
+* const error = new VisulimaError({
+*    hint: "Try running `npm install` to install missing dependencies.",
+*    location: {
+*    file: "src/index.ts",
+*    line: 1,
+*    column: 1,
+*    },
+*    message: "Cannot find module 'react'",
+*    name: "ModuleNotFoundError",
+* });
+* ```
+*
+* For more complex hints, you can pass an array of strings or a single string in markdown format.
+*/
+type ErrorHint = string[] | string;
+declare class VisulimaError extends Error {
+  loc: ErrorLocation | undefined;
+  title: string | undefined;
+  /**
+  * A message that explains to the user how they can fix the error.
+  */
+  hint: ErrorHint | undefined;
+  type: string;
+  constructor({
+    cause,
+    hint,
+    location,
+    message,
+    name,
+    stack,
+    title
+  }: ErrorProperties);
+  setLocation(location: ErrorLocation): void;
+  setName(name: string): void;
+  setMessage(message: string): void;
+  setHint(hint: ErrorHint): void;
+}
+/**
+* Will return an array of all causes in the error in the order they occurred.
+*/
+type Options$1 = Omit<CodeFrameOptions, "message | prefix"> & {
+  color: CodeFrameOptions["color"] & {
+    fileLine: ColorizeMethod;
+    hint: ColorizeMethod;
+    method: ColorizeMethod;
+    title: ColorizeMethod;
+  };
+  cwd: string;
+  displayShortPath: boolean;
+  filterStacktrace: ((line: string) => boolean) | undefined;
+  framesMaxLimit: number;
+  hideErrorCauseCodeView: boolean;
+  hideErrorCodeView: boolean;
+  hideErrorErrorsCodeView: boolean;
+  hideErrorTitle: boolean;
+  hideMessage: boolean;
+  indentation: number | "	";
+  prefix: string;
+};
+export { Options$1 as O, VisulimaError as V };

package/dist/packem_shared/lazyNamed-B278Tf9_.js

@@ -0,0 +1,6 @@
+const lazyNamed = (load, key) => async () => {
+  const module_ = await load();
+  return { default: module_[key] };
+};
+
+export { lazyNamed };