@visulima/cerebro 3.0.0-alpha.2 → 3.0.0-alpha.21

package/dist/types/command-line-usage.d.ts

@@ -1,37 +0,0 @@
-import type { TableOptions } from "@visulima/tabular";
-import type { ArgumentDefinition, OptionDefinition } from "./command.d.ts";
-/** A Content section comprises a header and one or more lines of content. */
-export interface Content {
-    /**
-     * Overloaded property, accepting data in one of four formats.
-     * 1. A single string (one line of text).
-     * 2. An array of strings (multiple lines of text).
-     * 3. An array of arrays (recordset-style data). In this case, the data will be rendered in table format.
-     * 4. An object with two properties - data and options. In this case, the data and options will be passed directly to the underlying table module for rendering.
-     */
-    content?: string[] | string[][] | string | {
-        data: string[][];
-        options: TableOptions;
-    };
-    /** The section header, always bold and underlined. */
-    header?: string;
-    /** Set to true to avoid indentation and wrapping. Useful for banners. */
-    raw?: boolean;
-}
-/** A OptionList section adds a table displaying details of the available options. */
-export interface OptionList<O extends OptionDefinition<any> = any> {
-    /** If specified, only options from this particular group will be printed.  */
-    group?: string[] | string;
-    header?: string | undefined;
-    /** The names of one of more option definitions to hide from the option list.  */
-    hide?: string[] | string;
-    /** If specified, the -- prefix will be omitted from the option name. */
-    isArgument?: boolean;
-    /** An array of option definition objects. */
-    optionList?: (ArgumentDefinition | O | OptionDefinition<boolean[]> | OptionDefinition<boolean> | OptionDefinition<number[]> | OptionDefinition<number> | OptionDefinition<string[]> | OptionDefinition<string>)[];
-    /** If true, the option alias will be displayed after the name, i.e. --verbose, -v instead of -v, --verbose). */
-    reverseNameOrder?: boolean;
-    /** An options object suitable for passing into table. */
-    tableOptions?: TableOptions;
-}
-export type Section = Content | OptionList;

package/dist/types/command.d.ts

@@ -1,136 +0,0 @@
-import type { OptionDefinition as BaseOptionDefinition } from "@visulima/command-line-args";
-import type { Content } from "./command-line-usage.d.ts";
-import type { Toolbox as IToolbox } from "./toolbox.d.ts";
-type TypeConstructor<T> = (value: unknown) => T extends (infer R)[] ? R | undefined : T | undefined;
-/**
- * Type constructor for environment variables.
- * Environment variables are always strings (or undefined), so the transform function receives string | undefined.
- */
-type EnvTypeConstructor<T> = (value: string | undefined) => T extends (infer R)[] ? R | undefined : T | undefined;
-type MultiplePropertyOptions<T> = T extends ReadonlyArray<unknown> ? {
-    lazyMultiple: true;
-} | {
-    multiple: true;
-} : unknown;
-export type OptionDefinition<T> = MultiplePropertyOptions<T> & Omit<BaseOptionDefinition, "type|defaultValue"> & {
-    __camelCaseName__?: string;
-    __negated__?: true;
-    /**
-     * A string or array of strings indicating the conflicting option(s).
-     * Note: The default value for an option does not cause a conflict.
-     */
-    conflicts?: string[] | string;
-    /** An initial value for the option. */
-    defaultValue?: T | undefined;
-    /** A string describing the option. */
-    description?: string | undefined;
-    /** Option is hidden from help */
-    hidden?: boolean;
-    implies?: Record<string, unknown>;
-    /** Specifies whether the variable is required. */
-    required?: boolean;
-    /**
-     * A setter function (you receive the output from this) enabling you to be specific about the type and value received. Typical values
-     * are `String`, `Number` and `Boolean` but you can use a custom function.
-     */
-    type?: TypeConstructor<T> | undefined;
-    /** A string to replace the default type string (e.g. &lt;string>). It's often more useful to set a more descriptive type label, like &lt;ms>, &lt;files>, &lt;command>, etc.. */
-    typeLabel?: string | undefined;
-};
-export type PossibleOptionDefinition<OD> = OD | OptionDefinition<boolean[]> | OptionDefinition<boolean> | OptionDefinition<number[]> | OptionDefinition<number> | OptionDefinition<string[]> | OptionDefinition<string>;
-export type ArgumentDefinition<T = unknown> = Omit<OptionDefinition<T>, "multiple|lazyMultiple|defaultOption|alias|group|defaultValue">;
-/**
- * Environment variable definition for commands.
- * Used to document and provide type-safe access to environment variables a command supports.
- * @template T The type of the environment variable value
- */
-export interface EnvDefinition<T = string> {
-    /** Default value if the environment variable is not set */
-    defaultValue?: T | undefined;
-    /** A description of what the environment variable does */
-    description?: string | undefined;
-    /** Environment variable is hidden from help */
-    hidden?: boolean;
-    /** The name of the environment variable */
-    name: string;
-    /**
-     * A transform function to convert the string environment variable value to the desired type.
-     * Typical values are `String`, `Number`, `Boolean` or custom functions.
-     * The function receives `string | undefined` and should return the transformed value.
-     */
-    type?: EnvTypeConstructor<T> | undefined;
-    /** A string to replace the default type string (e.g. &lt;string>). Useful for more descriptive type labels. */
-    typeLabel?: string | undefined;
-}
-export type PossibleEnvDefinition = EnvDefinition<boolean> | EnvDefinition<number> | EnvDefinition<string>;
-/**
- * Command interface with type-safe options and environment variables.
- * @template O - The option definition type
- * @template TContext - The toolbox context type (allows custom typing for better autocomplete)
- * @example
- * ```typescript
- * // Define your options type for autocomplete
- * type BuildOptions = {
- *   output?: string;
- *   production?: boolean;
- *   watch?: boolean;
- * };
- *
- * type BuildEnv = {
- *   apiKey?: string;
- *   debug?: boolean;
- * };
- *
- * cli.addCommand({
- *   name: "build",
- *   options: [
- *     { name: "output", type: String, alias: "o" },
- *     { name: "production", type: Boolean },
- *     { name: "watch", type: Boolean }
- *   ],
- *   env: [
- *     { name: "API_KEY", type: String },
- *     { name: "DEBUG", type: Boolean }
- *   ],
- *   execute: ({ options, env }: Toolbox<Console, BuildOptions, BuildEnv>) => {
- *     // Full autocomplete on options and env!
- *     console.log(options.output, options.production, env.apiKey);
- *   }
- * });
- * ```
- */
-export interface Command<O extends OptionDefinition<unknown> = OptionDefinition<unknown>, TLogger extends Console = Console, TContext extends IToolbox<TLogger> = IToolbox<TLogger>> {
-    /**
-     * @internal
-     */
-    __conflictingOptions__?: PossibleOptionDefinition<O>[];
-    /**
-     * @internal
-     */
-    __requiredOptions__?: PossibleOptionDefinition<O>[];
-    /** Potential other names for this command */
-    alias?: string[] | string;
-    /** Positional argument */
-    argument?: ArgumentDefinition;
-    /** The command path, an array that describes how to get to this command */
-    commandPath?: string[];
-    /** A tweet-sized summary of your command */
-    description?: string;
-    /** Environment variables supported by this command */
-    env?: (EnvDefinition<boolean> | EnvDefinition<number> | EnvDefinition<string>)[];
-    /** The full command examples, can be multiple lines */
-    examples?: string[] | string[][];
-    /** The function for running your command, can be async */
-    execute: ((toolbox: TContext) => Promise<void>) | ((toolbox: TContext) => void);
-    /** The path to the file name for this command. */
-    file?: string;
-    /** Group commands together under a heading */
-    group?: string;
-    /** Should your command be shown in the listings  */
-    hidden?: boolean;
-    /** The name of your command */
-    name: string;
-    options?: (O | OptionDefinition<boolean[]> | OptionDefinition<boolean> | OptionDefinition<number[]> | OptionDefinition<number> | OptionDefinition<string[]> | OptionDefinition<string>)[];
-    usage?: Content[];
-}
-export {};

package/dist/types/option-types.d.ts

@@ -1,83 +0,0 @@
-/**
- * Helper types for creating type-safe commands with autocomplete support.
- * These types help you define your options and environment variables with full TypeScript autocomplete.
- * Use these types to create type-safe Toolbox interfaces for your commands.
- * @example
- * ```typescript
- * import { CreateOptions, CreateEnv, type Toolbox } from '@visulima/cerebro';
- *
- * // Define options with their original names (they'll be converted to camelCase)
- * type BuildOptions = CreateOptions<{
- *   "output-dir": string | undefined;
- *   "verbose": boolean | undefined;
- *   "port": number | undefined;
- * }>;
- * // Result: { outputDir: string | undefined, verbose: boolean | undefined, port: number | undefined }
- *
- * // Define environment variables (UPPER_SNAKE_CASE -> camelCase)
- * type BuildEnv = CreateEnv<{
- *   "API_KEY": string | undefined;
- *   "DEBUG": boolean | undefined;
- * }>;
- * // Result: { apiKey: string | undefined, debug: boolean | undefined }
- *
- * // Use in your command
- * cli.addCommand({
- *   name: "build",
- *   options: [
- *     { name: "output-dir", type: String },
- *     { name: "verbose", type: Boolean },
- *     { name: "port", type: Number }
- *   ],
- *   env: [
- *     { name: "API_KEY", type: String },
- *     { name: "DEBUG", type: Boolean }
- *   ],
- *   execute: ({ options, env }: Toolbox<Console, BuildOptions, BuildEnv>) => {
- *     // Full autocomplete on options.outputDir, options.verbose, env.apiKey, etc.
- *     console.log(options.outputDir, options.verbose, env.apiKey);
- *   }
- * });
- * ```
- */
-/**
- * Converts option names to camelCase for the options object.
- * Options like "output-dir" become "outputDir" in the toolbox.
- * @example
- * ```typescript
- * // Option name: "output-dir" -> options.outputDir
- * // Option name: "api_key" -> options.apiKey
- * // Option name: "verbose" -> options.verbose
- * ```
- */
-export type OptionNameToCamelCase<T extends string> = T extends `${infer Start}-${infer Rest}` ? `${Lowercase<Start>}${Capitalize<OptionNameToCamelCase<Rest>>}` : T extends `${infer Start}_${infer Rest}` ? `${Lowercase<Start>}${Capitalize<OptionNameToCamelCase<Rest>>}` : Lowercase<T>;
-/**
- * Helper type to create a type-safe options object from option definitions.
- * @example
- * ```typescript
- * type MyOptions = CreateOptions<{
- *   "output-dir": string | undefined;
- *   "verbose": boolean | undefined;
- *   "port": number | undefined;
- * }>;
- * // Result: { outputDir: string | undefined, verbose: boolean | undefined, port: number | undefined }
- * ```
- */
-export type CreateOptions<T extends Record<string, unknown>> = {
-    [K in keyof T as OptionNameToCamelCase<K & string>]: T[K];
-};
-/**
- * Helper type to create a type-safe environment variables object from env definitions.
- * Environment variable names are converted from UPPER_SNAKE_CASE to camelCase.
- * @example
- * ```typescript
- * type MyEnv = CreateEnv<{
- *   "API_KEY": string | undefined;
- *   "DEBUG": boolean | undefined;
- * }>;
- * // Result: { apiKey: string | undefined, debug: boolean | undefined }
- * ```
- */
-export type CreateEnv<T extends Record<string, unknown>> = {
-    [K in keyof T as OptionNameToCamelCase<K & string>]: T[K];
-};

package/dist/types/options.d.ts

@@ -1,4 +0,0 @@
-/**
- * A flexible object for the many "options" objects we throw around in cerebro.
- */
-export type Options = Record<string | symbol, unknown>;

package/dist/types/plugin.d.ts

@@ -1,53 +0,0 @@
-import type { Cli } from "./cli.d.ts";
-import type { Toolbox } from "./toolbox.d.ts";
-/**
- * Context provided to plugins during initialization
- */
-export interface PluginContext<T extends Console = Console> {
-    /** The CLI instance */
-    cli: Cli<T>;
-    /** Current working directory */
-    cwd: string;
-    /** Logger instance */
-    logger: T;
-}
-/**
- * Plugin interface with lifecycle hooks
- */
-export interface Plugin<T extends Console = Console> {
-    /**
-     * Called after command execution completes successfully
-     * @param toolbox The command toolbox
-     * @param result The result returned by the command
-     */
-    afterCommand?: (toolbox: Toolbox<T>, result: unknown) => Promise<void> | void;
-    /**
-     * Called before command execution
-     * @param toolbox The command toolbox
-     */
-    beforeCommand?: (toolbox: Toolbox<T>) => Promise<void> | void;
-    /** Plugin dependencies (other plugin names that must be loaded first) */
-    dependencies?: string[];
-    /** Plugin description */
-    description?: string;
-    /**
-     * Called during command execution (for plugins that extend toolbox functionality)
-     * @param toolbox The command toolbox
-     */
-    execute?: (toolbox: Toolbox<T>) => Promise<void> | void;
-    /**
-     * Called once during plugin initialization
-     * @param context The plugin context
-     */
-    init?: (context: PluginContext<T>) => Promise<void> | void;
-    /** Plugin name (must be unique) */
-    name: string;
-    /**
-     * Called when an error occurs during command execution
-     * @param error The error that occurred
-     * @param toolbox The command toolbox
-     */
-    onError?: (error: Error, toolbox: Toolbox<T>) => Promise<void> | void;
-    /** Plugin version */
-    version?: string;
-}

package/dist/types/toolbox.d.ts

@@ -1,96 +0,0 @@
-import type { Cli as ICli } from "./cli.d.ts";
-import type { Command as ICommand } from "./command.d.ts";
-import type { Options } from "./options.d.ts";
-/**
- * Type-safe Toolbox interface with customizable options and environment variable types.
- * @template TLogger - The logger type (defaults to Console)
- * @template TOptions - The options type (defaults to Options/Record<string, unknown>)
- * @template TEnv - The environment variables type (defaults to Record<string, unknown>)
- */
-export interface Toolbox<TLogger extends Console = Console, TOptions extends Record<string, unknown> = Options, TEnv extends Record<string, unknown> = Record<string, unknown>> extends Cerebro.ExtensionOverrides {
-    /**
-     * The argument passed to the command.
-     * For example, if you run `cerebro foo bar baz`, then this will be `["foo", "bar", "baz"]`.
-     * @example
-     * ```typescript
-     * cli.addCommand({
-     *   name: "copy",
-     *   argument: {
-     *     name: "files",
-     *     type: String,
-     *     description: "Files to copy"
-     *   },
-     *   execute: ({ argument }) => {
-     *     // argument is an array of strings
-     *     // argument[0] is the first file, argument[1] is the second, etc.
-     *     argument.forEach((file) => console.log(`Copying ${file}...`));
-     *   }
-     * });
-     * ```
-     */
-    argument: string[];
-    argv: ReadonlyArray<string>;
-    /**
-     * The command that is being executed.
-     */
-    command: ICommand;
-    /**
-     * The name of the command that is being executed.
-     */
-    commandName: string;
-    /**
-     * Environment variables processed from the command definition.
-     * Values are transformed according to their type definitions and default values.
-     * @example
-     * ```typescript
-     * // Define env types when creating command
-     * type MyEnv = { apiKey: string; debug: boolean };
-     *
-     * cli.addCommand({
-     *   name: "build",
-     *   env: [
-     *     { name: "API_KEY", type: String },
-     *     { name: "DEBUG", type: Boolean }
-     *   ],
-     *   execute: ({ env }) => {
-     *     // env.apiKey and env.debug are now typed!
-     *     console.log(env.apiKey, env.debug);
-     *   }
-     * });
-     * ```
-     */
-    env: TEnv;
-    /** The logger instance. */
-    logger: TLogger;
-    /**
-     * Any optional parameters. Typically coming from command-line
-     * argument like this: `--force -p tsconfig-mjson`.
-     * @example
-     * ```typescript
-     * // Define options type for better autocomplete
-     * type MyOptions = {
-     *   output?: string;
-     *   verbose?: boolean;
-     *   port?: number;
-     * };
-     *
-     * cli.addCommand({
-     *   name: "serve",
-     *   options: [
-     *     { name: "output", type: String },
-     *     { name: "verbose", type: Boolean },
-     *     { name: "port", type: Number }
-     *   ],
-     *   execute: ({ options }: { options: MyOptions }) => {
-     *     // options.output, options.verbose, options.port are typed!
-     *     console.log(options.output, options.verbose, options.port);
-     *   }
-     * });
-     * ```
-     */
-    options: TOptions;
-    /**
-     * This is the instance of the CLI that is running the command.
-     */
-    runtime: ICli<TLogger>;
-}

package/dist/util/arg-processing/get-boolean-values.d.ts

@@ -1,7 +0,0 @@
-import type { OptionDefinition, PossibleOptionDefinition } from "../../types/command.d.ts";
-/**
- * Gets the values of any boolean arguments that were specified on the command line with a value.
- * These arguments were removed by removeBooleanValues.
- */
-declare const getBooleanValues: <OD extends OptionDefinition<unknown>>(arguments_: string[], options: PossibleOptionDefinition<OD>[], optionMapByName?: Map<string, PossibleOptionDefinition<OD>>, optionMapByAlias?: Map<string, PossibleOptionDefinition<OD>>) => Partial<OD>;
-export default getBooleanValues;

package/dist/util/arg-processing/get-parameter-option.d.ts

@@ -1,7 +0,0 @@
-import type { OptionDefinition, PossibleOptionDefinition } from "../../types/command.d.ts";
-declare const getParameterOption: <OD extends OptionDefinition<unknown>>(argument: string, options: PossibleOptionDefinition<OD>[], optionMapByName?: Map<string, PossibleOptionDefinition<OD>>, optionMapByAlias?: Map<string, PossibleOptionDefinition<OD>>) => {
-    argName?: string;
-    argValue?: string;
-    option?: PossibleOptionDefinition<OD>;
-};
-export default getParameterOption;

package/dist/util/arg-processing/map-option-type-label.d.ts

@@ -1,3 +0,0 @@
-import type { OptionDefinition, PossibleOptionDefinition } from "../../types/command.d.ts";
-declare const mapOptionTypeLabel: <OD extends OptionDefinition<any>>(definition: PossibleOptionDefinition<OD>) => PossibleOptionDefinition<OD>;
-export default mapOptionTypeLabel;

package/dist/util/arg-processing/option-is-boolean.d.ts

@@ -1,9 +0,0 @@
-import type { OptionDefinition, PossibleOptionDefinition } from "../../types/command.d.ts";
-/**
- * Determines whether an option definition is typed as Boolean.
- * @template OD
- * @param option Option definition to inspect.
- * @returns True when the option's type constructor is the built-in `Boolean`.
- */
-declare const optionIsBoolean: <OD extends OptionDefinition<unknown>>(option: PossibleOptionDefinition<OD>) => boolean;
-export default optionIsBoolean;

package/dist/util/arg-processing/remove-boolean-values.d.ts

@@ -1,9 +0,0 @@
-import type { OptionDefinition, PossibleOptionDefinition } from "../../types/command.d.ts";
-/**
- * Removes boolean values from arguments to prevent commandLineArgs errors.
- * commandLineArgs throws an error if we pass a value for a boolean arg as follows:
- * myCommand -a=true --booleanArg=false --otherArg true
- * This function removes these booleans to avoid errors from commandLineArgs.
- */
-declare const removeBooleanValues: <OD extends OptionDefinition<any>>(arguments_: string[], options: PossibleOptionDefinition<OD>[], optionMapByName?: Map<string, PossibleOptionDefinition<OD>>, optionMapByAlias?: Map<string, PossibleOptionDefinition<OD>>) => string[];
-export default removeBooleanValues;

package/dist/util/command-line-commands.d.ts

@@ -1,10 +0,0 @@
-/**
- * Copied from
- * The MIT License (MIT)
- * Copyright (c) 2015-21 Lloyd Brookes <75pound@gmail.com>
- */
-declare const commandLineCommands: (commands: (string | null)[], argv: string[]) => {
-    argv: string[];
-    command: string | null;
-};
-export default commandLineCommands;

package/dist/util/command-line-usage/get-terminal-width.d.ts

@@ -1,7 +0,0 @@
-/**
- * Gets the terminal width from the CEREBRO_TERMINAL_WIDTH environment variable.
- * Falls back to undefined if not set, allowing the tabular package to detect it automatically.
- * @returns The terminal width as a number, or undefined if not set
- */
-declare const getTerminalWidth: () => number | undefined;
-export default getTerminalWidth;

package/dist/util/command-line-usage/index.d.ts

@@ -1,3 +0,0 @@
-import type { Section as ISection } from "../../types/command-line-usage.d.ts";
-declare const commandLineUsage: (sections: ISection[]) => string;
-export default commandLineUsage;

package/dist/util/command-line-usage/section/base-section.d.ts

@@ -1,8 +0,0 @@
-declare class BaseSection {
-    protected lines: string[];
-    constructor();
-    add(line: string): void;
-    toString(): string;
-    header(text: string): void;
-}
-export default BaseSection;

package/dist/util/command-line-usage/section/content-section.d.ts

@@ -1,65 +0,0 @@
-import type { Content as IContent } from "../../../types/command-line-usage.d.ts";
-import BaseSection from "./base-section.d.ts";
-/**
- * A Content section comprises a header and one or more lines of content.
- * @property header The section header, always bold and underlined.
- * @property content Overloaded property, accepting data in one of four formats:
- *
- * 1. A single string (one line of text)
- * 2. An array of strings (multiple lines of text)
- * 3. An array of objects (recordset-style data). In this case, the data will be rendered in table format. The property names of each object are not important, so long as they are consistent throughout the array.
- * 4. An object with two properties - `data` and `options`. In this case, the data and options will be passed directly to the underlying [table](https://github.com/visulima/visulima/tree/main/packages/tabular) module for rendering.
- * @property raw - Set to true to avoid indentation and wrapping. Useful for banners.
- * @example
- * Simple string of content. For ansi formatting, use [colorize template literal syntax](https://github.com/visulima/visulima/tree/main/packages/colorize#tagged-template-literals).
- * ```js
- * {
- *   header: 'A typical app',
- *   content: 'Generates something {rgb(255,200,0).italic very {underline.bgRed important}}.'
- * }
- * ```
- *
- * An array of strings is interpreted as lines, to be joined by the system newline character.
- * ```js
- * {
- *   header: 'A typical app',
- *   content: [
- *     'First line.',
- *     'Second line.'
- *   ],
- * }
- * ```
- *
- * An array of arrays is rendered in table layout.
- * ```js
- * {
- *   header: 'A typical app',
- *   content: [
- *     [ 'First row, first column.', 'First row, second column.', ],
- *     [ 'Second row, first column.', 'Second row, second column.', ],
- *   ]
- * }
- * ```
- *
- * An object with `data` and `options` properties will be passed directly to the underlying [table](https://github.com/cli-table/cli-table3) module for rendering.
- * ```js
- * {
- *   header: 'A typical app',
- *   content: {
- *     data: [
- *         [ 'First row, first column.', 'First row, second column.', ],
- *         [ 'Second row, first column.', 'Second row, second column.', ],
- *         'Second row, first column.',
- *     ],
- *     options: {
- *       colWidths: [80],
- *     }
- *   }
- * }
- * ```
- */
-declare class ContentSection extends BaseSection {
-    constructor(section: IContent);
-    private getContentLines;
-}
-export default ContentSection;

package/dist/util/command-line-usage/section/option-list-section.d.ts

@@ -1,44 +0,0 @@
-import type { OptionList as IOptionList } from "../../../types/command-line-usage.d.ts";
-import BaseSection from "./base-section.d.ts";
-declare class OptionListSection extends BaseSection {
-    constructor(data: IOptionList);
-    private getOptionNames;
-    private intersect;
-}
-/**
- * An OptionList section adds a table displaying the supplied option definitions.
- * @property {string} [header] - The section header, always bold and underlined.
- * @property optionList {OptionDefinition[]} - An array of [option definition](https://github.com/75lb/command-line-args/blob/master/doc/option-definition.md) objects. In addition to the regular definition properties, command-line-usage will look for:
- *
- * - `description` - a string describing the option.
- * - `typeLabel` - a string to replace the default type string (e.g. `<string>`). It's often more useful to set a more descriptive type label, like `<ms>`, `<files>`, `<command>` etc.
- * @property {string|string[]} [group] - If specified, only options from this particular group will be printed. [Example](https://github.com/75lb/command-line-usage/blob/master/example/groups.js).
- * @property {string|string[]} [hide] - The names of one of more option definitions to hide from the option list. [Example](https://github.com/75lb/command-line-usage/blob/master/example/hide.js).
- * @property {boolean} [reverseNameOrder] - If true, the option alias will be displayed after the name, i.e. `--verbose, -v` instead of `-v, --verbose`).
- * @property {object} [tableOptions] - An options object suitable for passing into [table-layout](https://github.com/75lb/table-layout#table-). See [here for an example](https://github.com/75lb/command-line-usage/blob/master/example/option-list-options.js).
- * @example
- * {
- * header: 'Options',
- * optionList: [
- * {
- * name: 'help',
- * alias: 'h',
- * description: 'Display this usage guide.'
- * },
- * {
- * name: 'src',
- * description: 'The input files to process',
- * multiple: true,
- * defaultOption: true,
- * typeLabel: '{underline file} ...'
- * },
- * {
- * name: 'timeout',
- * description: 'Timeout value in ms.',
- * alias: 't',
- * typeLabel: '{underline ms}'
- * }
- * ]
- * }
- */
-export default OptionListSection;

package/dist/util/command-processing/command-processor.d.ts

@@ -1,37 +0,0 @@
-import type { CommandLineOptions } from "@visulima/command-line-args";
-import type { Command as ICommand, OptionDefinition } from "../../types/command.d.ts";
-import type { Toolbox as IToolbox } from "../../types/toolbox.d.ts";
-import mergeArguments from "../data-processing/merge-arguments.d.ts";
-/**
- * Prepares the toolbox for command execution.
- * @template OD The option definition type.
- * @param command The command to prepare toolbox for.
- * @param parsedArgs Parsed command-line arguments.
- * @param booleanValues Extracted boolean flag values.
- * @param extraOptions Additional options to merge into toolbox.
- * @returns The prepared toolbox instance.
- */
-export declare const prepareToolbox: <OD extends OptionDefinition<unknown>, TLogger extends Console = Console>(command: ICommand<OD, TLogger>, parsedArgs: CommandLineOptions, booleanValues: Record<string, unknown>, extraOptions: Record<string, unknown>) => IToolbox<TLogger>;
-/**
- * Processes command arguments and options.
- * @template OD The option definition type.
- * @param command The command to process arguments for.
- * @param commandArguments Raw command-line argument strings.
- * @param defaultOptions Default option definitions to merge.
- * @returns Object containing merged arguments, boolean values, and parsed args.
- * @throws {Error} When an argument has both multiple and lazyMultiple options.
- */
-export declare const processCommandArgs: <OD extends OptionDefinition<unknown>, TLogger extends Console = Console>(command: ICommand<OD, TLogger>, commandArguments: string[], defaultOptions: OptionDefinition<unknown>[]) => {
-    arguments_: ReturnType<typeof mergeArguments>;
-    booleanValues: Record<string, unknown>;
-    parsedArgs: CommandLineOptions;
-};
-/**
- * Executes a command and returns its result.
- * @template OD The option definition type.
- * @param command The command to execute.
- * @param toolbox The prepared toolbox for command execution.
- * @param _commandArgs Parsed command arguments.
- * @returns Promise resolving to the command execution result.
- */
-export declare const executeCommand: <OD extends OptionDefinition<unknown>, TLogger extends Console = Console>(command: ICommand<OD, TLogger>, toolbox: IToolbox<TLogger>, _commandArgs: CommandLineOptions) => Promise<unknown>;

package/dist/util/command-processing/command-validation.d.ts

@@ -1,17 +0,0 @@
-import type { CommandLineOptions } from "@visulima/command-line-args";
-import type { Command as ICommand, OptionDefinition, PossibleOptionDefinition } from "../../types/command.d.ts";
-import type { Toolbox as IToolbox } from "../../types/toolbox.d.ts";
-/**
- * Validates that all required options are present.
- * Uses pre-computed required options metadata from command registration for performance.
- */
-export declare const validateRequiredOptions: <OD extends OptionDefinition<unknown>, TLogger extends Console = Console>(arguments_: PossibleOptionDefinition<OD>[], commandArguments: CommandLineOptions, command: ICommand<OD, TLogger>) => void;
-/**
- * Validates for conflicting options.
- * Uses pre-computed conflict metadata from command registration for performance.
- */
-export declare const validateConflictingOptions: <OD extends OptionDefinition<unknown>, TLogger extends Console = Console>(arguments_: PossibleOptionDefinition<OD>[], commandArguments: IToolbox["options"], command: ICommand<OD, TLogger>) => void;
-/**
- * Validates for duplicate option definitions.
- */
-export declare const validateDuplicateOptions: <OD extends OptionDefinition<unknown>>(command: ICommand<OD>) => void;