tessl/npm-yargs-parser

The mighty option parser used by yargs for parsing command-line arguments with extensive configuration options.

Overview

Eval results

Files

String Utilities

Name: tessl/npm-yargs-parser
Author: tessl

yargs-parser provides utility functions for string manipulation and number detection that are also exposed as part of the public API. These utilities are used internally by the parser and can be useful for external applications.

Import

import parser from "yargs-parser";

API

function parser.camelCase(str: string): string;
function parser.decamelize(str: string, joinString?: string): string;
function parser.looksLikeNumber(x: null | undefined | number | string): boolean;

camelCase

Converts hyphenated or underscored strings to camelCase format. This is the same function used internally for camel-case expansion.

Usage

import parser from "yargs-parser";

console.log(parser.camelCase('foo-bar'));          // 'fooBar'
console.log(parser.camelCase('hello_world'));      // 'helloWorld'
console.log(parser.camelCase('multi-word-option')); // 'multiWordOption'
console.log(parser.camelCase('already-camelCase')); // 'alreadyCamelCase'
console.log(parser.camelCase('UPPER-CASE'));       // 'upperCase'

Special Cases

// Preserves existing camelCase
console.log(parser.camelCase('fooBar'));           // 'fooBar'

// Handles leading hyphens
console.log(parser.camelCase('--foo-bar'));        // 'fooBar'

// Mixed case handling
console.log(parser.camelCase('XMLHttpRequest'));   // 'XMLHttpRequest' (unchanged)

// Numbers and special characters
console.log(parser.camelCase('option-123-test'));  // 'option123Test'
console.log(parser.camelCase('foo--bar'));         // 'fooBar'

Empty and Edge Cases

console.log(parser.camelCase(''));                 // ''
console.log(parser.camelCase('a'));                // 'a'
console.log(parser.camelCase('-'));                // ''
console.log(parser.camelCase('---'));              // ''
console.log(parser.camelCase('a-'));               // 'a'
console.log(parser.camelCase('-a'));               // 'a'

decamelize

Converts camelCase strings to hyphenated format (or custom separator). This is the reverse operation of camelCase.

Basic Usage

import parser from "yargs-parser";

console.log(parser.decamelize('fooBar'));          // 'foo-bar'
console.log(parser.decamelize('helloWorld'));      // 'hello-world'
console.log(parser.decamelize('multiWordOption')); // 'multi-word-option'
console.log(parser.decamelize('XMLHttpRequest'));  // 'x-m-l-http-request'

Custom Separator

// Using underscore separator
console.log(parser.decamelize('fooBar', '_'));     // 'foo_bar'
console.log(parser.decamelize('helloWorld', '_')); // 'hello_world'

// Using dot separator
console.log(parser.decamelize('fooBar', '.'));     // 'foo.bar'

// Using space separator
console.log(parser.decamelize('helloWorld', ' ')); // 'hello world'

Special Cases

// Already lowercase
console.log(parser.decamelize('lowercase'));       // 'lowercase'

// Single character
console.log(parser.decamelize('a'));               // 'a'
console.log(parser.decamelize('A'));               // 'a'

// Numbers
console.log(parser.decamelize('option123Test'));   // 'option123-test'

// Consecutive capitals
console.log(parser.decamelize('HTTPSProxy'));      // 'h-t-t-p-s-proxy'

Default Separator Behavior

// Without separator parameter, defaults to hyphen
console.log(parser.decamelize('fooBar'));          // 'foo-bar'
console.log(parser.decamelize('fooBar', undefined)); // 'foo-bar'
console.log(parser.decamelize('fooBar', ''));      // 'foobar' (empty separator)

looksLikeNumber

Determines if a value appears to be a number that can be parsed. This is used internally to decide when to apply automatic number conversion.

Basic Usage

import parser from "yargs-parser";

// Integer-like strings
console.log(parser.looksLikeNumber('123'));        // true
console.log(parser.looksLikeNumber('0'));          // true
console.log(parser.looksLikeNumber('-456'));       // true

// Decimal numbers
console.log(parser.looksLikeNumber('3.14'));       // true
console.log(parser.looksLikeNumber('-2.5'));       // true
console.log(parser.looksLikeNumber('.5'));         // true

// Scientific notation
console.log(parser.looksLikeNumber('1e5'));        // true
console.log(parser.looksLikeNumber('2.5e-3'));     // true
console.log(parser.looksLikeNumber('1E10'));       // true

Hexadecimal Numbers

// Hexadecimal notation
console.log(parser.looksLikeNumber('0x1F'));       // true
console.log(parser.looksLikeNumber('0XFF'));       // true
console.log(parser.looksLikeNumber('0x0'));        // true

Non-Number Values

// Strings that are not numbers
console.log(parser.looksLikeNumber('hello'));      // false
console.log(parser.looksLikeNumber('123abc'));     // false
console.log(parser.looksLikeNumber(''));           // false

// Special string cases
console.log(parser.looksLikeNumber('NaN'));        // false
console.log(parser.looksLikeNumber('Infinity'));   // false
console.log(parser.looksLikeNumber('-Infinity'));  // false

Octal Numbers (Special Handling)

// Leading zeros are treated specially to avoid octal interpretation
console.log(parser.looksLikeNumber('0123'));       // false (to prevent octal)
console.log(parser.looksLikeNumber('0.123'));      // true (decimal with leading zero)
console.log(parser.looksLikeNumber('007'));        // false (to prevent octal)

Null and Undefined

// Null and undefined values
console.log(parser.looksLikeNumber(null));         // false
console.log(parser.looksLikeNumber(undefined));    // false

// Actual numbers (already parsed)
console.log(parser.looksLikeNumber(123));          // true
console.log(parser.looksLikeNumber(0));            // true
console.log(parser.looksLikeNumber(-456));         // true

Integration Examples

Using Utilities with Parsing

import parser from "yargs-parser";

// Check if values look like numbers before parsing
const args = ['--port', '3000', '--name', 'server', '--timeout', '30s'];

args.forEach((arg, index) => {
  if (arg.startsWith('--') && index + 1 < args.length) {
    const value = args[index + 1];
    console.log(`${arg}: ${value} -> looks like number: ${parser.looksLikeNumber(value)}`);
  }
});
// Output:
// --port: 3000 -> looks like number: true
// --name: server -> looks like number: false
// --timeout: 30s -> looks like number: false

Converting Between Formats

// Convert CLI options to different formats
function convertOptionFormat(option: string, toCamelCase: boolean = false) {
  if (toCamelCase) {
    return parser.camelCase(option);
  } else {
    // Assume input is camelCase, convert to hyphenated
    return parser.decamelize(option);
  }
}

console.log(convertOptionFormat('database-url', true));   // 'databaseUrl'
console.log(convertOptionFormat('databaseUrl', false));   // 'database-url'

Custom Number Validation

// Strict number validation using looksLikeNumber
function parseStrictNumbers(args: string[]) {
  return parser(args, {
    coerce: {
      port: (arg: any) => {
        if (!parser.looksLikeNumber(arg)) {
          throw new Error(`Port must be a number, got: ${arg}`);
        }
        return parseInt(arg, 10);
      }
    }
  });
}

try {
  const result = parseStrictNumbers(['--port', '3000abc']);
} catch (error) {
  console.error(error.message); // "Port must be a number, got: 3000abc"
}

Option Name Standardization

// Standardize option names across different input formats
function standardizeOptions(options: Record<string, any>) {
  const standardized: Record<string, any> = {};
  
  for (const [key, value] of Object.entries(options)) {
    // Convert all keys to camelCase for consistent internal representation
    const standardKey = parser.camelCase(key);
    standardized[standardKey] = value;
  }
  
  return standardized;
}

const mixed = {
  'database-url': 'postgres://localhost',
  'max_connections': 100,
  'enableLogging': true
};

console.log(standardizeOptions(mixed));
// Output: { databaseUrl: 'postgres://localhost', maxConnections: 100, enableLogging: true }

Install with Tessl CLI