args-tokens 0.2.5 → 0.3.1

package/lib/cjs/index.d.ts

@@ -1,64 +1,3 @@
-/**
- * Argument token Kind
- * - `option`: option token, support short option (e.g. `-x`) and long option (e.g. `--foo`)
- * - `option-terminator`: option terminator (`--`) token, see guideline 10 in https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html
- * - `positional`: positional token
- */
-export type ArgTokenKind = 'option' | 'option-terminator' | 'positional';
-/**
- * Argument token
- */
-export interface ArgToken {
-    /**
-     * Argument token kind
-     */
-    kind: ArgTokenKind;
-    /**
-     * Argument token index, e.g `--foo bar` => `--foo` index is 0, `bar` index is 1
-     */
-    index: number;
-    /**
-     * Option name, e.g. `--foo` => `foo`, `-x` => `x`
-     */
-    name?: string;
-    /**
-     * Raw option name, e.g. `--foo` => `--foo`, `-x` => `-x`
-     */
-    rawName?: string;
-    /**
-     * Option value, e.g. `--foo=bar` => `bar`, `-x=bar` => `bar`.
-     * If the `allowCompatible` option is `true`, short option value will be same as Node.js `parseArgs` behavior.
-     */
-    value?: string;
-    /**
-     * Inline value, e.g. `--foo=bar` => `true`, `-x=bar` => `true`.
-     */
-    inlineValue?: boolean;
-}
-/**
- * Parse Options
- */
-export interface ParseOptions {
-    /**
-     * [Node.js parseArgs](https://nodejs.org/api/util.html#parseargs-tokens) tokens compatible mode
-     * @default false
-     */
-    allowCompatible?: boolean;
-}
-/**
- * Parse command line arguments
- * @example
- * ```js
- * import { parseArgs } from 'args-tokens' // for Node.js and Bun
- * // import { parseArgs } from 'jsr:@kazupon/args-tokens' // for Deno
- *
- * const tokens = parseArgs(['--foo', 'bar', '-x', '--bar=baz'])
- * // do something with using tokens
- * // ...
- * console.log('tokens:', tokens)
- * ```
- * @param args command line arguments
- * @param options parse options
- * @returns argument tokens
- */
-export declare function parseArgs(args: string[], options?: ParseOptions): ArgToken[];
+export { parseArgs } from './parser.js';
+export * from './resolver.js';
+export type { ArgToken, ParseOptions } from './parser';

package/lib/cjs/index.js

@@ -1,228 +1,20 @@
 "use strict";
-// SPDX-License-Identifier: MIT
-// Modifier: kazuya kawaguchi (a.k.a. kazupon)
-// Forked from `nodejs/node` (`pkgjs/parseargs`)
-// Repository url: https://github.com/nodejs/node (https://github.com/pkgjs/parseargs)
-// Author: Node.js contributors
-// Code url: https://github.com/nodejs/node/blob/main/lib/internal/util/parse_args/parse_args.js
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseArgs = parseArgs;
-const HYPHEN_CHAR = '-';
-const HYPHEN_CODE = HYPHEN_CHAR.codePointAt(0);
-const EQUAL_CHAR = '=';
-const EQUAL_CODE = EQUAL_CHAR.codePointAt(0);
-const TERMINATOR = '--';
-const SHORT_OPTION_PREFIX = HYPHEN_CHAR;
-const LONG_OPTION_PREFIX = '--';
-/**
- * Parse command line arguments
- * @example
- * ```js
- * import { parseArgs } from 'args-tokens' // for Node.js and Bun
- * // import { parseArgs } from 'jsr:@kazupon/args-tokens' // for Deno
- *
- * const tokens = parseArgs(['--foo', 'bar', '-x', '--bar=baz'])
- * // do something with using tokens
- * // ...
- * console.log('tokens:', tokens)
- * ```
- * @param args command line arguments
- * @param options parse options
- * @returns argument tokens
- */
-function parseArgs(args, options = {}) {
-    const { allowCompatible = false } = options;
-    const tokens = [];
-    const remainings = [...args];
-    let index = -1;
-    let groupCount = 0;
-    let hasShortValueSeparator = false;
-    while (remainings.length > 0) {
-        const arg = remainings.shift();
-        if (arg == undefined) {
-            break;
-        }
-        const nextArg = remainings[0];
-        if (groupCount > 0) {
-            groupCount--;
-        }
-        else {
-            index++;
-        }
-        // check if `arg` is an options terminator.
-        // guideline 10 in https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html
-        if (arg === TERMINATOR) {
-            tokens.push({
-                kind: 'option-terminator',
-                index
-            });
-            const mapped = remainings.map(arg => {
-                return { kind: 'positional', index: ++index, value: arg };
-            });
-            tokens.push(...mapped);
-            break;
-        }
-        if (isShortOption(arg)) {
-            const shortOption = arg.charAt(1);
-            let value;
-            let inlineValue;
-            if (groupCount) {
-                // e.g. `-abc`
-                tokens.push({
-                    kind: 'option',
-                    name: shortOption,
-                    rawName: arg,
-                    index,
-                    value,
-                    inlineValue
-                });
-                if (groupCount === 1 && hasOptionValue(nextArg)) {
-                    value = remainings.shift();
-                    if (hasShortValueSeparator) {
-                        inlineValue = true;
-                        hasShortValueSeparator = false;
-                    }
-                    tokens.push({
-                        kind: 'option',
-                        index,
-                        value,
-                        inlineValue
-                    });
-                }
-            }
-            else {
-                // e.g. `-a`
-                tokens.push({
-                    kind: 'option',
-                    name: shortOption,
-                    rawName: arg,
-                    index,
-                    value,
-                    inlineValue
-                });
-            }
-            // eslint-disable-next-line unicorn/no-null
-            if (value != null) {
-                ++index;
-            }
-            continue;
-        }
-        if (isShortOptionGroup(arg)) {
-            // expend short option group (e.g. `-abc` => `-a -b -c`, `-f=bar` => `-f bar`)
-            const expanded = [];
-            let shortValue = '';
-            for (let i = 1; i < arg.length; i++) {
-                const shortableOption = arg.charAt(i);
-                if (hasShortValueSeparator) {
-                    shortValue += shortableOption;
-                }
-                else {
-                    if (!allowCompatible && shortableOption.codePointAt(0) === EQUAL_CODE) {
-                        hasShortValueSeparator = true;
-                    }
-                    else {
-                        expanded.push(`${SHORT_OPTION_PREFIX}${shortableOption}`);
-                    }
-                }
-            }
-            if (shortValue) {
-                expanded.push(shortValue);
-            }
-            remainings.unshift(...expanded);
-            groupCount = expanded.length;
-            continue;
-        }
-        if (isLongOption(arg)) {
-            // e.g. `--foo`
-            const longOption = arg.slice(2);
-            tokens.push({
-                kind: 'option',
-                name: longOption,
-                rawName: arg,
-                index,
-                value: undefined,
-                inlineValue: undefined
-            });
-            continue;
-        }
-        if (isLongOptionAndValue(arg)) {
-            // e.g. `--foo=bar`
-            const equalIndex = arg.indexOf(EQUAL_CHAR);
-            const longOption = arg.slice(2, equalIndex);
-            const value = arg.slice(equalIndex + 1);
-            tokens.push({
-                kind: 'option',
-                name: longOption,
-                rawName: `${LONG_OPTION_PREFIX}${longOption}`,
-                index,
-                value,
-                inlineValue: true
-            });
-            continue;
-        }
-        tokens.push({
-            kind: 'positional',
-            index,
-            value: arg
-        });
-    }
-    return tokens;
-}
-/**
- * Check if `arg` is a short option (e.g. `-f`)
- * @param arg the argument to check
- * @returns whether `arg` is a short option
- */
-function isShortOption(arg) {
-    return (arg.length === 2 && arg.codePointAt(0) === HYPHEN_CODE && arg.codePointAt(1) !== HYPHEN_CODE);
-}
-/**
- * Check if `arg` is a short option group (e.g. `-abc`)
- * @param arg the argument to check
- * @returns whether `arg` is a short option group
- */
-function isShortOptionGroup(arg) {
-    if (arg.length <= 2) {
-        return false;
-    }
-    if (arg.codePointAt(0) !== HYPHEN_CODE) {
-        return false;
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    if (arg.codePointAt(1) === HYPHEN_CODE) {
-        return false;
-    }
-    return true;
-}
-/**
- * Check if `arg` is a long option (e.g. `--foo`)
- * @param arg the argument to check
- * @returns whether `arg` is a long option
- */
-function isLongOption(arg) {
-    return hasLongOptionPrefix(arg) && !arg.includes(EQUAL_CHAR, 3);
-}
-/**
- * Check if `arg` is a long option with value (e.g. `--foo=bar`)
- * @param arg the argument to check
- * @returns whether `arg` is a long option
- */
-function isLongOptionAndValue(arg) {
-    return hasLongOptionPrefix(arg) && arg.includes(EQUAL_CHAR, 3);
-}
-/**
- * Check if `arg` is a long option prefix (e.g. `--`)
- * @param arg the argument to check
- * @returns whether `arg` is a long option prefix
- */
-function hasLongOptionPrefix(arg) {
-    return arg.length > 2 && ~arg.indexOf(LONG_OPTION_PREFIX);
-}
-/**
- * Check if a `value` is an option value
- * @param value a value to check
- * @returns whether a `value` is an option value
- */
-function hasOptionValue(value) {
-    // eslint-disable-next-line unicorn/no-null
-    return !(value == null) && value.codePointAt(0) !== HYPHEN_CODE;
-}
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = void 0;
+var parser_js_1 = require("./parser.js");
+Object.defineProperty(exports, "parseArgs", { enumerable: true, get: function () { return parser_js_1.parseArgs; } });
+__exportStar(require("./resolver.js"), exports);

package/lib/cjs/parser.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Argument token Kind
+ * - `option`: option token, support short option (e.g. `-x`) and long option (e.g. `--foo`)
+ * - `option-terminator`: option terminator (`--`) token, see guideline 10 in https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html
+ * - `positional`: positional token
+ */
+type ArgTokenKind = 'option' | 'option-terminator' | 'positional';
+/**
+ * Argument token
+ */
+export interface ArgToken {
+    /**
+     * Argument token kind
+     */
+    kind: ArgTokenKind;
+    /**
+     * Argument token index, e.g `--foo bar` => `--foo` index is 0, `bar` index is 1
+     */
+    index: number;
+    /**
+     * Option name, e.g. `--foo` => `foo`, `-x` => `x`
+     */
+    name?: string;
+    /**
+     * Raw option name, e.g. `--foo` => `--foo`, `-x` => `-x`
+     */
+    rawName?: string;
+    /**
+     * Option value, e.g. `--foo=bar` => `bar`, `-x=bar` => `bar`.
+     * If the `allowCompatible` option is `true`, short option value will be same as Node.js `parseArgs` behavior.
+     */
+    value?: string;
+    /**
+     * Inline value, e.g. `--foo=bar` => `true`, `-x=bar` => `true`.
+     */
+    inlineValue?: boolean;
+}
+/**
+ * Parse Options
+ */
+export interface ParseOptions {
+    /**
+     * [Node.js parseArgs](https://nodejs.org/api/util.html#parseargs-tokens) tokens compatible mode
+     * @default false
+     */
+    allowCompatible?: boolean;
+}
+/**
+ * Parse command line arguments
+ * @example
+ * ```js
+ * import { parseArgs } from 'args-tokens' // for Node.js and Bun
+ * // import { parseArgs } from 'jsr:@kazupon/args-tokens' // for Deno
+ *
+ * const tokens = parseArgs(['--foo', 'bar', '-x', '--bar=baz'])
+ * // do something with using tokens
+ * // ...
+ * console.log('tokens:', tokens)
+ * ```
+ * @param args command line arguments
+ * @param options parse options
+ * @returns argument tokens
+ */
+export declare function parseArgs(args: string[], options?: ParseOptions): ArgToken[];
+/**
+ * Check if `arg` is a short option (e.g. `-f`)
+ * @param arg the argument to check
+ * @returns whether `arg` is a short option
+ */
+export declare function isShortOption(arg: string): boolean;
+/**
+ * Check if `arg` is a long option prefix (e.g. `--`)
+ * @param arg the argument to check
+ * @returns whether `arg` is a long option prefix
+ */
+export declare function hasLongOptionPrefix(arg: string): number | false;
+export {};

package/lib/cjs/parser.js

@@ -0,0 +1,230 @@
+"use strict";
+// SPDX-License-Identifier: MIT
+// Modifier: kazuya kawaguchi (a.k.a. kazupon)
+// Forked from `nodejs/node` (`pkgjs/parseargs`)
+// Repository url: https://github.com/nodejs/node (https://github.com/pkgjs/parseargs)
+// Author: Node.js contributors
+// Code url: https://github.com/nodejs/node/blob/main/lib/internal/util/parse_args/parse_args.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.isShortOption = isShortOption;
+exports.hasLongOptionPrefix = hasLongOptionPrefix;
+const HYPHEN_CHAR = '-';
+const HYPHEN_CODE = HYPHEN_CHAR.codePointAt(0);
+const EQUAL_CHAR = '=';
+const EQUAL_CODE = EQUAL_CHAR.codePointAt(0);
+const TERMINATOR = '--';
+const SHORT_OPTION_PREFIX = HYPHEN_CHAR;
+const LONG_OPTION_PREFIX = '--';
+/**
+ * Parse command line arguments
+ * @example
+ * ```js
+ * import { parseArgs } from 'args-tokens' // for Node.js and Bun
+ * // import { parseArgs } from 'jsr:@kazupon/args-tokens' // for Deno
+ *
+ * const tokens = parseArgs(['--foo', 'bar', '-x', '--bar=baz'])
+ * // do something with using tokens
+ * // ...
+ * console.log('tokens:', tokens)
+ * ```
+ * @param args command line arguments
+ * @param options parse options
+ * @returns argument tokens
+ */
+function parseArgs(args, options = {}) {
+    const { allowCompatible = false } = options;
+    const tokens = [];
+    const remainings = [...args];
+    let index = -1;
+    let groupCount = 0;
+    let hasShortValueSeparator = false;
+    while (remainings.length > 0) {
+        const arg = remainings.shift();
+        if (arg == undefined) {
+            break;
+        }
+        const nextArg = remainings[0];
+        if (groupCount > 0) {
+            groupCount--;
+        }
+        else {
+            index++;
+        }
+        // check if `arg` is an options terminator.
+        // guideline 10 in https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html
+        if (arg === TERMINATOR) {
+            tokens.push({
+                kind: 'option-terminator',
+                index
+            });
+            const mapped = remainings.map(arg => {
+                return { kind: 'positional', index: ++index, value: arg };
+            });
+            tokens.push(...mapped);
+            break;
+        }
+        if (isShortOption(arg)) {
+            const shortOption = arg.charAt(1);
+            let value;
+            let inlineValue;
+            if (groupCount) {
+                // e.g. `-abc`
+                tokens.push({
+                    kind: 'option',
+                    name: shortOption,
+                    rawName: arg,
+                    index,
+                    value,
+                    inlineValue
+                });
+                if (groupCount === 1 && hasOptionValue(nextArg)) {
+                    value = remainings.shift();
+                    if (hasShortValueSeparator) {
+                        inlineValue = true;
+                        hasShortValueSeparator = false;
+                    }
+                    tokens.push({
+                        kind: 'option',
+                        index,
+                        value,
+                        inlineValue
+                    });
+                }
+            }
+            else {
+                // e.g. `-a`
+                tokens.push({
+                    kind: 'option',
+                    name: shortOption,
+                    rawName: arg,
+                    index,
+                    value,
+                    inlineValue
+                });
+            }
+            // eslint-disable-next-line unicorn/no-null
+            if (value != null) {
+                ++index;
+            }
+            continue;
+        }
+        if (isShortOptionGroup(arg)) {
+            // expend short option group (e.g. `-abc` => `-a -b -c`, `-f=bar` => `-f bar`)
+            const expanded = [];
+            let shortValue = '';
+            for (let i = 1; i < arg.length; i++) {
+                const shortableOption = arg.charAt(i);
+                if (hasShortValueSeparator) {
+                    shortValue += shortableOption;
+                }
+                else {
+                    if (!allowCompatible && shortableOption.codePointAt(0) === EQUAL_CODE) {
+                        hasShortValueSeparator = true;
+                    }
+                    else {
+                        expanded.push(`${SHORT_OPTION_PREFIX}${shortableOption}`);
+                    }
+                }
+            }
+            if (shortValue) {
+                expanded.push(shortValue);
+            }
+            remainings.unshift(...expanded);
+            groupCount = expanded.length;
+            continue;
+        }
+        if (isLongOption(arg)) {
+            // e.g. `--foo`
+            const longOption = arg.slice(2);
+            tokens.push({
+                kind: 'option',
+                name: longOption,
+                rawName: arg,
+                index,
+                value: undefined,
+                inlineValue: undefined
+            });
+            continue;
+        }
+        if (isLongOptionAndValue(arg)) {
+            // e.g. `--foo=bar`
+            const equalIndex = arg.indexOf(EQUAL_CHAR);
+            const longOption = arg.slice(2, equalIndex);
+            const value = arg.slice(equalIndex + 1);
+            tokens.push({
+                kind: 'option',
+                name: longOption,
+                rawName: `${LONG_OPTION_PREFIX}${longOption}`,
+                index,
+                value,
+                inlineValue: true
+            });
+            continue;
+        }
+        tokens.push({
+            kind: 'positional',
+            index,
+            value: arg
+        });
+    }
+    return tokens;
+}
+/**
+ * Check if `arg` is a short option (e.g. `-f`)
+ * @param arg the argument to check
+ * @returns whether `arg` is a short option
+ */
+function isShortOption(arg) {
+    return (arg.length === 2 && arg.codePointAt(0) === HYPHEN_CODE && arg.codePointAt(1) !== HYPHEN_CODE);
+}
+/**
+ * Check if `arg` is a short option group (e.g. `-abc`)
+ * @param arg the argument to check
+ * @returns whether `arg` is a short option group
+ */
+function isShortOptionGroup(arg) {
+    if (arg.length <= 2) {
+        return false;
+    }
+    if (arg.codePointAt(0) !== HYPHEN_CODE) {
+        return false;
+    }
+    if (arg.codePointAt(1) === HYPHEN_CODE) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Check if `arg` is a long option (e.g. `--foo`)
+ * @param arg the argument to check
+ * @returns whether `arg` is a long option
+ */
+function isLongOption(arg) {
+    return hasLongOptionPrefix(arg) && !arg.includes(EQUAL_CHAR, 3);
+}
+/**
+ * Check if `arg` is a long option with value (e.g. `--foo=bar`)
+ * @param arg the argument to check
+ * @returns whether `arg` is a long option
+ */
+function isLongOptionAndValue(arg) {
+    return hasLongOptionPrefix(arg) && arg.includes(EQUAL_CHAR, 3);
+}
+/**
+ * Check if `arg` is a long option prefix (e.g. `--`)
+ * @param arg the argument to check
+ * @returns whether `arg` is a long option prefix
+ */
+function hasLongOptionPrefix(arg) {
+    return arg.length > 2 && ~arg.indexOf(LONG_OPTION_PREFIX);
+}
+/**
+ * Check if a `value` is an option value
+ * @param value a value to check
+ * @returns whether a `value` is an option value
+ */
+function hasOptionValue(value) {
+    // eslint-disable-next-line unicorn/no-null
+    return !(value == null) && value.codePointAt(0) !== HYPHEN_CODE;
+}

package/lib/cjs/resolver.d.ts

@@ -0,0 +1,50 @@
+import type { ArgToken } from './parser';
+/**
+ * An option schema for an argument.
+ */
+export interface ArgOptionSchema {
+    /**
+     * Type of argument.
+     */
+    type: 'string' | 'boolean' | 'number';
+    /**
+     * A single character alias for the option.
+     */
+    short?: string;
+    /**
+     * Whether the argument is required or not.
+     */
+    required?: true;
+    /**
+     * The default value of the argument.
+     */
+    default?: string | boolean | number;
+}
+/**
+ * An object that contains {@link ArgOptionSchema | options schema}.
+ */
+export interface ArgOptions {
+    [option: string]: ArgOptionSchema;
+}
+/**
+ * An object that contains the values of the arguments.
+ */
+export type ArgValues<T> = T extends ArgOptions ? ResolveArgValues<T, {
+    [Option in keyof T]: ExtractOptionValue<T[Option]>;
+}> : {
+    [option: string]: string | boolean | number | undefined;
+};
+type ExtractOptionValue<O extends ArgOptionSchema> = O['type'] extends 'string' ? string : O['type'] extends 'boolean' ? boolean : O['type'] extends 'number' ? number : string | boolean | number;
+type ResolveArgValues<O extends ArgOptions, V extends Record<keyof O, unknown>> = {
+    -readonly [Option in keyof O]?: V[Option];
+} & FilterArgs<O, V, 'default'> & FilterArgs<O, V, 'required'> extends infer P ? {
+    [K in keyof P]: P[K];
+} : never;
+type FilterArgs<O extends ArgOptions, V extends Record<keyof O, unknown>, K extends keyof ArgOptionSchema> = {
+    [Option in keyof O as O[Option][K] extends {} ? Option : never]: V[Option];
+};
+export declare function resolveArgs<T extends ArgOptions>(options: T, tokens: ArgToken[]): {
+    values: ArgValues<T>;
+    positionals: string[];
+};
+export {};