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

package/dist/packem_shared/{Cerebro-CXEIHSN2.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';
@@ -1133,6 +1132,19 @@ class EmptyToolbox {
   }
 }
 
+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);
@@ -1285,6 +1297,26 @@ 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, _unknown, positionals } = parsedArgs;
@@ -1294,7 +1326,7 @@ const prepareToolbox = (command, parsedArgs, booleanValues, extraOptions) => {
     delete mergedAll[POSITIONALS_KEY];
   }
   toolbox.argument = positionals?.[POSITIONALS_KEY] ?? [];
-  toolbox.rawUnknown = (_unknown ?? []).slice();
+  toolbox.rawUnknown = [..._unknown ?? []];
   const hasExtraOptions = Object.keys(extraOptions).length > 0;
   toolbox.options = hasExtraOptions ? { ...mergedAll, ...extraOptions } : mergedAll;
   toolbox.env = processEnvVariables(command.env);
@@ -1343,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;
@@ -3009,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);
@@ -3240,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();
@@ -3321,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;
     }
@@ -3403,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-DNXLgme3.js → index--1UArng3.js}

@@ -124,8 +124,7 @@ class ContentSection extends BaseSection {
       table.addRow([templateFormat(content)]);
       return table.toString();
     }
-    if (Array.isArray(content) && // eslint-disable-next-line @typescript-eslint/no-shadow
-    content.every((value) => typeof value === "string" || Array.isArray(value) && value.every((value2) => typeof value2 === "string"))) {
+    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: {

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 };