### Example of CLI Flags (Shell)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This shell command illustrates the basic syntax for passing flags (options) to a script. It demonstrates two common formats: `--flag-name value` and `--flag-name=value`, both assigning a value to a named flag.

```sh
$ my-script --file-a data.json --file-b=file.txt
```

--------------------------------

### Installing Cleye CLI Tool (Bash)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This command installs the `cleye` package from npm, making it available for use in Node.js projects. It's the first step to integrate `cleye` into your development environment.

```Bash
npm i cleye
```

--------------------------------

### Defining CLI Commands with Cleye (TypeScript)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This snippet illustrates how to define and register commands in a Cleye application. It uses the `command` function to create an 'install' command with specific parameters and flags, then registers it within the `cli` configuration's `commands` array. It also shows how to access the parsed command name and its parameters from the `argv` object.

```ts
import { cli, command } from 'cleye'

const argv = cli({
    name: 'npm',

    version: '1.2.3',

    commands: [
        command({
            // Command name
            name: 'install',

            parameters: ['<package name>'],

            flags: {
                noSave: Boolean,
                saveDev: Boolean
            }
        })
    ]
})

// $ npm install lodash

argv.command // => "install" (string)
argv._.packageName // => "lodash" (string)
```

--------------------------------

### Customizing Help Document Rendering in Cleye (TypeScript)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This example demonstrates how to customize the help document rendering in Cleye by modifying the `nodes` array and extending `renderers`. It adds a custom sentence at the end of the document and changes the flag operator from a space to an equals sign (`=`) for flag examples, enhancing the CLI's help output.

```ts
cli({
    // ...,

    help: {
        render(nodes, renderers) {
            /* Modify nodes... */

            // Add some text at end of document
            nodes.push('\nCheckout Cleye: https://github.com/privatenumber/cleye')

            /* Extend renderers... */

            // Make all flag examples use `=` as the separator
            renderers.flagOperator = () => '='

            /* Render nodes and return help */
            return renderers.render(nodes)
        }
    }
})
```

--------------------------------

### Defining a CLI with Parameters and Flags using Cleye (TypeScript)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This example demonstrates how to define a command-line interface using `cleye`. It parses command-line arguments, defines required and optional parameters (`<first name>`, `[last name]`), and a typed flag (`--time`). The script then uses these parsed values to generate a personalized greeting message.

```TypeScript
import { cli } from 'cleye'

// Parse argv
const argv = cli({
    name: 'greet.js',

    // Define parameters
    parameters: [
        '<first name>', // First name is required
        '[last name]' // Last name is optional
    ],

    // Define flags/options
    flags: {

        // Parses `--time` as a string
        time: {
            type: String,
            description: 'Time of day to greet (morning or evening)',
            default: 'morning'
        }
    }
})

const name = [argv._.firstName, argv._.lastName].filter(Boolean).join(' ')

if (argv.flags.time === 'morning') {
    console.log(`Good morning ${name}!`)
} else {
    console.log(`Good evening ${name}!`)
}
```

--------------------------------

### Illustrating End-of-Flags with npm run (Shell)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This example demonstrates the common use case of the end-of-flags marker (`--`) in shell commands, specifically with `npm run`. The `--` separates arguments intended for the script being run from those intended for `npm` itself, allowing for distinct parsing contexts.

```sh
$ npm run <script> -- <script arguments>
```

--------------------------------

### Parsing End-of-Flags Arguments with Cleye (TypeScript)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This snippet shows how to explicitly include the end-of-flags marker (`--`) within the `parameters` array in Cleye. This allows arguments following `--` to be parsed and assigned to a specific named parameter, such as `arguments` in this `npm-run` example, accessible via `argv._.arguments`.

```ts
const argv = cli({
    name: 'npm-run',
    parameters: [
        '<script>',
        '--',
        '[arguments...]'
    ]
})

// $ npm-run echo -- hello world

argv._.script // => "echo" (string)
argv._.arguments // => ["hello", "world] (string[])
```

--------------------------------

### Viewing Generated Help Documentation for Cleye CLI (Shell)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This snippet shows the automatically generated help documentation for the `greet.js` CLI script when invoked with the `--help` flag. It outlines the usage syntax, available flags, and their descriptions, demonstrating Cleye's built-in documentation generation feature.

```Shell
$ node greet.js --help

greet.js

Usage:
  greet.js [flags...] <first name> [last name]

Flags:
  -h, --help                 Show help
      --time <string>        Time of day to greet (morning or evening) (default: "morning")
```

--------------------------------

### Registering Command Callbacks in Cleye CLI Entry (TypeScript)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This snippet shows how to integrate a command defined with a callback (like `installCommand` from a separate file) into the main Cleye CLI entry point. It imports the pre-defined command and includes it in the `commands` array of the `cli` configuration, demonstrating a modular approach to building CLI applications.

```ts
import { installCommand } from './install-command.js'

cli({
    name: 'npm',

    commands: [
        installCommand
    ]
})
```

--------------------------------

### Executing a Cleye CLI Script with Arguments and Flags (Shell)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This command demonstrates how to execute the `greet.js` CLI script, passing 'John Doe' as parameters and `--time evening` as a flag. It illustrates the script's behavior based on the provided inputs, resulting in a customized greeting message.

```Shell
$ node greet.js John Doe --time evening

Good evening John Doe!
```

--------------------------------

### Implementing Command Callbacks in Cleye (TypeScript)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This snippet demonstrates how to define a Cleye command with a callback function, allowing for modular handling of command-specific logic. The `installCommand` is defined in its own file, accepting an `argv` object to process its specific parameters and flags, promoting better code organization for complex CLIs.

```ts
import { command } from 'cleye'

export const installCommand = command({
    // Command name
    name: 'install',

    parameters: ['<package name>'],

    flags: {
        noSave: Boolean,
        saveDev: Boolean
    }
}, (argv) => {
    // $ npm install lodash

    argv._.packageName // => "lodash" (string)
})
```

--------------------------------

### Testing Version Flag in Cleye (Shell)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This shell snippet demonstrates how to invoke the `--version` flag from the command line for a Cleye application configured with a version. It shows the expected output, which is the version string defined in the CLI configuration.

```sh
$ my-script --version
1.2.3
```

--------------------------------

### Defining and Accessing CLI Parameters with Cleye (TypeScript)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This snippet demonstrates how to define required, optional, and spread parameters using the `parameters` array in Cleye's `cli()` function. It shows how these parameters are accessed in camelCase on the `_` property of the returned `argv` object, illustrating their types (string, string | undefined, string[]).

```ts
const argv = cli({
    parameters: [
        '<required parameter>',
        '[optional parameter]',
        '[optional spread...]'
    ]
})

// $ my-script a b c d

argv._.requiredParameter // => "a" (string)
argv._.optionalParameter // => "b" (string | undefined)
argv._.optionalSpread // => ["c", "d"] (string[])
```

--------------------------------

### Enabling Version Flag in Cleye (TypeScript)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This snippet shows how to enable the `--version` flag in a Cleye application. By simply specifying the `version` property in the `cli` configuration object, Cleye automatically handles the `--version` flag, displaying the provided version string when invoked.

```ts
cli({
    version: '1.2.3'
})
```

--------------------------------

### Defining and Accessing CLI Flags with Cleye (TypeScript)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This snippet demonstrates how to define various types of flags (Boolean, String, Number) using the `flags` object in Cleye. It shows how to specify aliases, default values, descriptions, and how to allow multiple values for a flag by wrapping its type in an array. Flags are accessed via `argv.flags`.

```ts
const argv = cli({
    flags: {
        someBoolean: Boolean,

        someString: {
            type: String,
            description: 'Some string flag',
            default: 'n/a'
        },

        someNumber: {
            // Wrap the type function in an array to allow multiple values
            type: [Number],
            alias: 'n',
            description: 'Array of numbers. (eg. -n 1 -n 2 -n 3)'
        }
    }
})

// $ my-script --some-boolean --some-string hello --some-number 1 -n 2

argv.flags.someBoolean // => true (boolean | undefined)
argv.flags.someString // => "hello" (string)
argv.flags.someNumber // => [1, 2] (number[])
```

--------------------------------

### Defining ParsedArgv Return Type for Cleye CLI (TypeScript)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This TypeScript type definition outlines the structure of the `ParsedArgv` object returned by the `cli` function in Cleye. It includes properties for parsed arguments (`_`), parsed flags (`flags`), unexpected flags (`unknownFlags`), and methods to display version (`showVersion`) and help (`showHelp`) information.

```ts
type ParsedArgv = {
    // Parsed arguments
    _: string[] & Parameters

    // Parsed flags
    flags: {
        [flagName: string]: InferredType
    }

    // Unexpected flags
    unknownFlags: {
        [flagName: string]: (string | boolean)[]
    }

    // Method to print version
    showVersion: () => void

    // Method to print help
    showHelp: (options: HelpOptions) => void
}
```

--------------------------------

### Defining Custom Flag Types with Cleye (TypeScript)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This snippet demonstrates how to create custom flag types in Cleye for input validation and type narrowing. A custom function, `Size`, is defined to validate input against a set of `possibleSizes` and is then used as the `type` for a flag in the `cli` configuration. This ensures that the `size` flag only accepts predefined values.

```ts
const possibleSizes = ['small', 'medium', 'large'] as const

type Sizes = typeof possibleSizes[number] // => "small" | "medium" | "large"

// Custom type function
function Size(size: Sizes) {
    if (!possibleSizes.includes(size)) {
        throw new Error(`Invalid size: "${size}"`);
    }

    return size
}

const argv = cli({
    flags: {
        size: {
            type: Size,
            description: 'Size of the pizza (small, medium, large)'
        }
    }
})

// $ my-script --size large

argv.flags.size // => "large" ("small" | "medium" | "large")
```

--------------------------------

### Accessing Positional Arguments in Cleye (TypeScript)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This snippet illustrates how to access positional arguments passed to a `cleye` CLI script. The `_` property of the `argv` object contains an array of all non-flag arguments, allowing direct access to values like filenames or other unflagged inputs.

```TypeScript
const argv = cli({ /* ... */ })

// $ my-script file-a.txt file-b.txt

argv._ // => ["file-a.txt", "file-b.txt"] (string[])
```

--------------------------------

### Defining IgnoreArgvCallback Type for Cleye CLI (TypeScript)

Source: https://github.com/privatenumber/cleye/blob/master/README.md

This TypeScript type defines the signature for the `ignoreArgv` callback function in Cleye. This callback allows developers to selectively ignore specific command-line argument tokens during parsing, based on their type (known flag, unknown flag, or argument), the flag/argument string, and its associated value.

```ts
type IgnoreArgvCallback = (
    type: 'known-flag' | 'unknown-flag' | 'argument',
    flagOrArgv: string,
    value: string | undefined,
) => boolean | void
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.