cli-nano 1.0.2 → 1.1.0

package/dist/index.d.ts

@@ -1,4 +1,9 @@
-import type { Config } from './interfaces.js';
-export type * from './interfaces.js';
-export declare function parseArgs(config: Config): Record<string, any>;
+import { ArgValueType, ArgsResult, ArgumentOptions, CommandOptions, Config, OptionsToObject, PositionalArgument, PositionalsToObject } from "./interfaces-CqSzltdU.js";
+
+//#region src/index.d.ts
+declare function parseArgs<C extends Config>(config: C): ArgsResult<C>;
+//# sourceMappingURL=index.d.ts.map
+
+//#endregion
+export { ArgValueType, ArgsResult, ArgumentOptions, CommandOptions, Config, OptionsToObject, PositionalArgument, PositionalsToObject, parseArgs };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAG/D,mBAAmB,iBAAiB,CAAC;AAErC,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAkO7D"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;iBASgB,oBAAoB,gBAAgB,IAAI,WAAW;AAAnE"}

package/dist/index.js

@@ -1,264 +1,3 @@
-import { camelToKebab, kebabToCamel, padString } from './utils.js';
-export function parseArgs(config) {
-    const { command, options, version } = config;
-    // Normalize args to support --option=value and -o=value
-    const args = process.argv.slice(2).flatMap(arg => {
-        if (/^--?\w[\w-]*=/.test(arg)) {
-            const [flag, ...rest] = arg.split('=');
-            return [flag, rest.join('=')];
-        }
-        return arg;
-    });
-    const result = {};
-    // Check for duplicate aliases
-    const aliasMap = new Map();
-    for (const [key, opt] of Object.entries(options)) {
-        if (opt.alias) {
-            const optAlias = opt.alias;
-            if (aliasMap.has(optAlias)) {
-                throw new Error(`Duplicate alias detected: "${opt.alias}" used for both "${aliasMap.get(optAlias)}" and "${key}"`);
-            }
-            aliasMap.set(optAlias, key);
-        }
-    }
-    // Handle --help and --version before anything else
-    if (args.includes('--help') || args.includes('-h')) {
-        printHelp(config);
-        process.exit(0);
-    }
-    if ((version && args.includes('--version')) || args.includes('-v')) {
-        console.log(version || 'No version specified');
-        process.exit(0);
-    }
-    // Validate: required positionals must come before optional ones
-    const positionals = command.positionals ?? [];
-    let foundOptional = false;
-    for (const pos of positionals) {
-        if (!pos.required) {
-            foundOptional = true;
-        }
-        if (foundOptional && pos.required) {
-            throw new Error(`Invalid positional argument configuration: required positional "${pos.name}" cannot follow optional positional(s).`);
-        }
-    }
-    // Handle positional arguments
-    let argIndex = 0;
-    const nonOptionArgs = [];
-    while (argIndex < args.length && !args[argIndex].startsWith('-')) {
-        nonOptionArgs.push(args[argIndex]);
-        argIndex++;
-    }
-    let nonOptionIndex = 0;
-    for (let i = 0; i < positionals.length; i++) {
-        const pos = positionals[i];
-        if (pos.variadic) {
-            const remaining = positionals.length - (i + 1);
-            const values = nonOptionArgs.slice(nonOptionIndex, nonOptionArgs.length - remaining);
-            if (pos.required && values.length === 0) {
-                const usagePositionals = positionals.map(posArg => `<${posArg.name}>`).join(' ');
-                throw new Error(`Missing required positional argument, i.e.: "${command.name} ${usagePositionals}"`);
-            }
-            result[pos.name] = !pos.required && values.length === 0 && pos.default !== undefined ? pos.default : values;
-            nonOptionIndex += values.length;
-        }
-        else {
-            const value = nonOptionArgs[nonOptionIndex];
-            // Check if there are enough args left for required positionals
-            const requiredLeft = positionals.slice(i).filter(p => p.required).length;
-            const argsLeft = nonOptionArgs.length - nonOptionIndex;
-            if (value !== undefined && (argsLeft > requiredLeft - (pos.required ? 1 : 0) || pos.required)) {
-                result[pos.name] = value;
-                nonOptionIndex++;
-            }
-            else if (!pos.required && pos.default !== undefined) {
-                result[pos.name] = pos.default;
-            }
-            else if (pos.required) {
-                const usagePositionals = positionals.map(posArg => `<${posArg.name}>`).join(' ');
-                throw new Error(`Missing required positional argument, i.e.: "${command.name} ${usagePositionals}"`);
-            }
-        }
-    }
-    // Handle options
-    // Start parsing options after all non-option args used for positionals
-    argIndex = 0;
-    const consumedArgs = new Set();
-    // Mark all nonOptionArgs indices as consumed for positionals
-    let tempNonOptionIndex = 0;
-    for (let i = 0; i < positionals.length; i++) {
-        const pos = positionals[i];
-        if (pos.variadic) {
-            const remaining = positionals.length - (i + 1);
-            const values = nonOptionArgs.slice(tempNonOptionIndex, nonOptionArgs.length - remaining);
-            for (let j = tempNonOptionIndex; j < tempNonOptionIndex + values.length; j++) {
-                consumedArgs.add(args.findIndex((a, idx) => !a.startsWith('-') && !consumedArgs.has(idx) && a === nonOptionArgs[j]));
-            }
-            tempNonOptionIndex += values.length;
-        }
-        else {
-            const value = nonOptionArgs[tempNonOptionIndex++];
-            consumedArgs.add(args.findIndex((a, idx) => !a.startsWith('-') && !consumedArgs.has(idx) && a === value));
-        }
-    }
-    while (argIndex < args.length) {
-        if (consumedArgs.has(argIndex)) {
-            argIndex++;
-            continue;
-        }
-        const argOrg = args[argIndex] || '';
-        let arg = args[argIndex];
-        let option;
-        let configKey;
-        if (argOrg.startsWith('-')) {
-            if (argOrg.startsWith('--')) {
-                arg = argOrg.slice(2);
-                // Try all forms: as-is, kebab-to-camel, camel-to-kebab
-                option = options[arg] || options[kebabToCamel(arg)] || options[camelToKebab(arg).replace(/-/g, '')];
-                if (option) {
-                    // Find the actual config key
-                    for (const key of Object.keys(options)) {
-                        if (options[key] === option) {
-                            configKey = key;
-                            break;
-                        }
-                    }
-                }
-                if (!option) {
-                    // Try matching aliases in all forms
-                    for (const key of Object.keys(options)) {
-                        const opt = options[key];
-                        if (opt.alias && (opt.alias.includes(arg) || opt.alias.includes(kebabToCamel(arg)) || opt.alias.includes(camelToKebab(arg)))) {
-                            option = opt;
-                            configKey = key;
-                            break;
-                        }
-                    }
-                }
-            }
-            else if (argOrg.startsWith('-')) {
-                // alias
-                arg = argOrg.slice(1);
-                if (arg) {
-                    const optionKeys = Object.keys(options);
-                    for (let j = 0; j < optionKeys.length; j++) {
-                        const opt = options[optionKeys[j]];
-                        if (opt.alias && (opt.alias === arg || opt.alias === kebabToCamel(arg) || opt.alias === camelToKebab(arg))) {
-                            option = opt;
-                            configKey = optionKeys[j];
-                            break;
-                        }
-                    }
-                }
-            }
-            if (!option) {
-                // Handle negated boolean in both forms
-                const isNegated = arg.startsWith('no-');
-                const optionName = isNegated ? arg.slice(3) : arg;
-                const camelOptionName = kebabToCamel(optionName);
-                option = options[optionName] || options[camelOptionName];
-                configKey = camelOptionName in options ? camelOptionName : optionName;
-                if (option?.type === 'boolean') {
-                    if (result[optionName] !== undefined || result[camelOptionName] !== undefined) {
-                        throw new Error('Providing same negated and truthy argument are not allowed');
-                    }
-                    result[configKey] = !isNegated;
-                    argIndex++;
-                    continue;
-                }
-            }
-            if (!option || !configKey) {
-                throw new Error(`Unknown CLI option: ${arg}`);
-            }
-            switch (option.type) {
-                case 'boolean':
-                    if (result[configKey] !== undefined) {
-                        throw new Error('Providing same negated and truthy argument are not allowed');
-                    }
-                    result[configKey] = !argOrg.startsWith('--no-') && !argOrg.startsWith('-no-');
-                    break;
-                case 'number':
-                    if (args[argIndex + 1] === undefined || args[argIndex + 1].startsWith('-')) {
-                        throw new Error(`Missing value for option: ${configKey}`);
-                    }
-                    result[configKey] = Number(args[++argIndex]);
-                    break;
-                case 'array': {
-                    if (!result[configKey])
-                        result[configKey] = [];
-                    const arrayValue = args[++argIndex];
-                    if (arrayValue === undefined || arrayValue.startsWith('-')) {
-                        throw new Error(`Missing value for array option: ${configKey}`);
-                    }
-                    result[configKey].push(arrayValue);
-                    break;
-                }
-                case 'string':
-                default:
-                    if (args[argIndex + 1] === undefined || args[argIndex + 1].startsWith('-')) {
-                        throw new Error(`Missing value for option: ${configKey}`);
-                    }
-                    result[configKey] = args[++argIndex];
-                    break;
-            }
-        }
-        else {
-            throw new Error(`Unknown argument: ${arg}`);
-        }
-        argIndex++;
-    }
-    // After all parsing, assign any `default` CLI options when undefined
-    // and check for any missing `required` CLI options
-    Object.entries(options).forEach(([key, opt]) => {
-        if (result[key] === undefined && opt.default !== undefined) {
-            result[key] = opt.default;
-        }
-        if (opt.required && result[key] === undefined) {
-            const aliasStr = opt.alias ? `-${opt.alias}, ` : '';
-            throw new Error(`Missing required option: ${aliasStr}--${key}`);
-        }
-    });
-    return result;
-}
-/** print CLI help documentation to the screen */
-function printHelp(config) {
-    const { command, options, version } = config;
-    // Helper to truncate with ellipsis
-    function truncateDesc(desc, max) {
-        return desc.length > max ? `${desc.slice(0, max - 3)}...` : desc;
-    }
-    // Build usage string for positionals
-    const usagePositionals = (command.positionals ?? [])
-        .map(p => {
-        const variadic = p.variadic ? '..' : '';
-        if (p.required) {
-            return `<${p.name}${variadic}>`;
-        }
-        return `[${p.name}${variadic}]`;
-    })
-        .join(' ');
-    console.log('Usage:');
-    console.log(`  ${command.name} ${usagePositionals} [options]  ${command.description}`);
-    console.log('\nPositionals:');
-    command.positionals?.forEach(arg => {
-        let desc = truncateDesc(arg.description, 65);
-        desc = desc.padEnd(65); // Always pad to 65 chars for alignment
-        console.log(`  ${arg.name.padEnd(20)}${desc} [${arg.type || 'string'}]`);
-    });
-    console.log('\nOptions:');
-    Object.keys(options).forEach(key => {
-        const option = options[key];
-        const requiredStr = option.required ? '[required]' : '';
-        const aliasStr = option.alias ? `-${option.alias}, ` : '';
-        let desc = truncateDesc(option.description || '', 65);
-        desc = desc.padEnd(65); // Always pad to 65 chars for alignment
-        console.log(`  ${aliasStr.padEnd(4)}--${key.padEnd(14)}${desc} [${option.type || 'string'}]${requiredStr}`);
-    });
-    // Print default options (help and version)
-    console.log('\nDefault options:');
-    console.log(`${padString('  -h, --help', 21)} ${padString('Show help', 65)} [boolean]`);
-    if (version) {
-        console.log(`${padString('  -v, --version', 21)} ${padString('Show version number', 65)} [boolean]`);
-    }
-    console.log('\n');
-}
-//# sourceMappingURL=index.js.map
+import { parseArgs } from "./src-DQnZ842s.js";
+
+export { parseArgs };

package/dist/interfaces-CqSzltdU.d.ts

@@ -0,0 +1,84 @@
+//#region src/interfaces.d.ts
+interface ArgumentOptions {
+  /** option type */
+  type?: 'string' | 'boolean' | 'number' | 'array';
+  /** description of the flag option */
+  description: string;
+  /** defaults to undefined, provide shorter alias as command options */
+  alias?: string;
+  /** default value for the option if not provided */
+  default?: any;
+  /** defaults to false, is the option required? */
+  required?: boolean;
+}
+interface PositionalArgument {
+  /** positional argument name (it will be displayed in the help docs) */
+  name: string;
+  /** positional argument description */
+  description: string;
+  /** postional argument type */
+  type?: 'string' | 'boolean' | 'number' | 'array';
+  /** defaults to false, allows multiple values for this positional argument */
+  variadic?: boolean;
+  /** default value for the option if not provided */
+  default?: any;
+  /** defaults to false, is the positional argument required? */
+  required?: boolean;
+}
+interface CommandOptions {
+  /** command name, used in the help docs */
+  name: string;
+  /** command description */
+  description: string;
+  /** list of positional arguments */
+  positionals?: readonly PositionalArgument[];
+}
+/** CLI options */
+interface Config {
+  /** CLI definition */
+  command: CommandOptions;
+  /** option name length (w/wo alias) shown in the help (defaults to 20) */
+  helpOptLength?: number;
+  /** description length shown in the help (defaults to 65) */
+  helpDescLength?: number;
+  /** CLI list of flag options */
+  options: Record<string, ArgumentOptions>;
+  /** CLI or package version */
+  version?: string;
+}
+/** Utility type to map ArgumentOptions/PositionalArgument to their value type */
+type ArgValueType<T extends {
+  type?: string;
+  default?: any;
+  variadic?: boolean;
+  required?: boolean;
+}> = T['type'] extends 'boolean' ? boolean : T['type'] extends 'number' ? number : T['type'] extends 'array' ? T extends {
+  variadic: true;
+} ? T extends {
+  required: true;
+} ? [string, ...string[]] : string[] : string | string[] : T['type'] extends 'string' ? T extends {
+  variadic: true;
+} ? T extends {
+  required: true;
+} ? [string, ...string[]] : string[] : string : T['type'] extends undefined ? T extends {
+  variadic: true;
+} ? T extends {
+  required: true;
+} ? [string, ...string[]] : string[] : string : T['default'] extends undefined ? string : T['default'];
+/** Helper to get required keys */
+type RequiredKeys<T> = { [K in keyof T]: T[K] extends {
+  required: true;
+} ? K : never }[keyof T];
+/** Helper to get optional keys */
+type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
+/** Map options record to an object type with required/optional properties */
+type OptionsToObject<T extends Record<string, any>> = { [K in RequiredKeys<T>]: ArgValueType<T[K]> } & { [K in OptionalKeys<T>]?: ArgValueType<T[K]> };
+/** Map positionals array to an object type with required/optional properties */
+type PositionalsToObject<T extends readonly PositionalArgument[] | undefined> = T extends readonly [infer P, ...infer Rest] ? P extends PositionalArgument ? (P['required'] extends true ? { [K in P['name']]: ArgValueType<P> } : { [K in P['name']]?: ArgValueType<P> }) & PositionalsToObject<Rest extends readonly PositionalArgument[] ? Rest : []> : PositionalsToObject<Rest extends readonly PositionalArgument[] ? Rest : []> : {
+  [key: string]: never;
+};
+/** The full result type for parseArgs */
+type ArgsResult<C extends Config> = PositionalsToObject<C['command']['positionals']> & OptionsToObject<C['options']>;
+//#endregion
+export { ArgValueType, ArgsResult, ArgumentOptions, CommandOptions, Config, OptionsToObject, PositionalArgument, PositionalsToObject };
+//# sourceMappingURL=interfaces-CqSzltdU.d.ts.map

package/dist/interfaces-CqSzltdU.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces-CqSzltdU.d.ts","names":[],"sources":["../src/interfaces.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/interfaces.d.ts

@@ -1,44 +1,2 @@
-export interface ArgumentOptions {
-    /** option type */
-    type?: 'string' | 'boolean' | 'number' | 'array';
-    /** description of the flag option */
-    description: string;
-    /** defaults to undefined, provide shorter aliases as command options */
-    alias?: string | string[];
-    /** default value for the option if not provided */
-    default?: any;
-    /** defaults to false, is the option required? */
-    required?: boolean;
-}
-export interface PositionalArgument {
-    /** positional argument name (it will be displayed in the help docs) */
-    name: string;
-    /** positional argument description */
-    description: string;
-    /** postional argument type */
-    type?: 'string' | 'boolean' | 'number' | 'array';
-    /** defaults to false, allows multiple values for this positional argument */
-    variadic?: boolean;
-    /** default value for the option if not provided */
-    default?: any;
-    /** defaults to false, is the positional argument required? */
-    required?: boolean;
-}
-export interface CommandOptions {
-    /** command name, used in the help docs */
-    name: string;
-    /** command description */
-    description: string;
-    /** list of positional arguments */
-    positionals?: PositionalArgument[];
-}
-/** CLI options */
-export interface Config {
-    /** CLI definition */
-    command: CommandOptions;
-    /** CLI list of flag options */
-    options: Record<string, ArgumentOptions>;
-    /** CLI or package version */
-    version?: string;
-}
-//# sourceMappingURL=interfaces.d.ts.map
+import { ArgValueType, ArgsResult, ArgumentOptions, CommandOptions, Config, OptionsToObject, PositionalArgument, PositionalsToObject } from "./interfaces-CqSzltdU.js";
+export { ArgValueType, ArgsResult, ArgumentOptions, CommandOptions, Config, OptionsToObject, PositionalArgument, PositionalsToObject };

package/dist/interfaces.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=interfaces.js.map