args-tokens 0.16.0 → 0.16.1

package/lib/index.d.ts

@@ -1,17 +1,19 @@
-import { ArgToken, ParserOptions, parseArgs$1 as parseArgs } from "./parser.d-Cheh2e-O.js";
-import { ArgOptionSchema, ArgOptions, ArgValues, OptionResolveError$1 as OptionResolveError, OptionResolveErrorType, ResolveArgsOptions, resolveArgs$1 as resolveArgs } from "./resolver.d-D6XfwWOY.js";
+import { ArgToken, ParserOptions, parseArgs$1 as parseArgs } from "./parser-Bx112mWZ.js";
+import { ArgOptionSchema, ArgOptions, ArgValues, OptionResolveError$1 as OptionResolveError, OptionResolveErrorType, ResolveArgsOptions, resolveArgs$1 as resolveArgs } from "./resolver-ByBRRKOK.js";
 
 //#region src/parse.d.ts
 /**
 * Parse options for {@link parse} function.
 */
+/**
+* Parse options for {@link parse} function.
+*/
 interface ParseOptions<O extends ArgOptions> extends ParserOptions, ResolveArgsOptions {
   /**
   * Command line options, about details see {@link ArgOptions}.
   */
   options?: O;
 }
-
 /**
 * Parsed command line arguments.
 */
@@ -36,21 +38,21 @@ type ParsedArgs<T extends ArgOptions> = {
   * Argument tokens, same as `tokens` which is parsed by {@link parseArgs}.
   */
   tokens: ArgToken[];
-}; /**
-   * Parse command line arguments.
-   * This function is a convenient API, that is used {@link parseArgs} and {@link resolveArgs} in internal.
-   * @example
-   * ```js
-   * import { parse } from 'args-tokens'
-   *
-   * const { values, positionals } = parse(process.argv.slice(2))
-   * console.log('values', values)
-   * console.log('positionals', positionals)
-   * ```
-   * @param args - command line arguments
-   * @param options - parse options, about details see {@link ParseOptions}
-   * @returns An object that contains the values of the arguments, positional arguments, {@link AggregateError | validation errors}, and {@link ArgToken | argument tokens}.
-   */
-
+};
+/**
+* Parse command line arguments.
+* This function is a convenient API, that is used {@link parseArgs} and {@link resolveArgs} in internal.
+* @example
+* ```js
+* import { parse } from 'args-tokens'
+*
+* const { values, positionals } = parse(process.argv.slice(2))
+* console.log('values', values)
+* console.log('positionals', positionals)
+* ```
+* @param args - command line arguments
+* @param options - parse options, about details see {@link ParseOptions}
+* @returns An object that contains the values of the arguments, positional arguments, {@link AggregateError | validation errors}, and {@link ArgToken | argument tokens}.
+*/
 declare function parse<O extends ArgOptions>(args: string[], options?: ParseOptions<O>): ParsedArgs<O>; //#endregion
 export { ArgOptionSchema, ArgOptions, ArgToken, ArgValues, OptionResolveError, OptionResolveErrorType, ParseOptions, ParsedArgs, ParserOptions, ResolveArgsOptions, parse, parseArgs, resolveArgs };

package/lib/{parser.d-Cheh2e-O.d.ts → parser-Bx112mWZ.d.ts}

@@ -16,8 +16,8 @@
 * - `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";
-
+*/
+type ArgTokenKind = "option" | "option-terminator" | "positional";
 /**
 * Argument token.
 */
@@ -47,44 +47,44 @@ interface ArgToken {
   * Inline value, e.g. `--foo=bar` => `true`, `-x=bar` => `true`.
   */
   inlineValue?: boolean;
-} /**
-  * Parser Options.
-  */
-
+}
+/**
+* Parser Options.
+*/
 interface ParserOptions {
   /**
   * [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.
-  */
-
-declare function parseArgs(args: string[], options?: ParserOptions): ArgToken[]; /**
-                                                                                 * Check if `arg` is a short option (e.g. `-f`).
-                                                                                 * @param arg the argument to check
-                                                                                 * @returns whether `arg` is a short option.
-                                                                                 */
-
-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.
-                                                      */
-
+}
+/**
+* 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.
+*/
+declare function parseArgs(args: string[], options?: ParserOptions): ArgToken[];
+/**
+* Check if `arg` is a short option (e.g. `-f`).
+* @param arg the argument to check
+* @returns whether `arg` is a short option.
+*/
+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.
+*/
 declare function hasLongOptionPrefix(arg: string): boolean; //#endregion
 export { ArgToken, ParserOptions, hasLongOptionPrefix as hasLongOptionPrefix$1, isShortOption as isShortOption$1, parseArgs as parseArgs$1 };

package/lib/parser.d.ts

@@ -1,2 +1,2 @@
-import { ArgToken, ParserOptions, hasLongOptionPrefix$1 as hasLongOptionPrefix, isShortOption$1 as isShortOption, parseArgs$1 as parseArgs } from "./parser.d-Cheh2e-O.js";
+import { ArgToken, ParserOptions, hasLongOptionPrefix$1 as hasLongOptionPrefix, isShortOption$1 as isShortOption, parseArgs$1 as parseArgs } from "./parser-Bx112mWZ.js";
 export { ArgToken, ParserOptions, hasLongOptionPrefix, isShortOption, parseArgs };

package/lib/{resolver.d-D6XfwWOY.d.ts → resolver-ByBRRKOK.d.ts}

@@ -1,4 +1,4 @@
-import { ArgToken } from "./parser.d-Cheh2e-O.js";
+import { ArgToken } from "./parser-Bx112mWZ.js";
 
 //#region src/resolver.d.ts
 /**
@@ -10,6 +10,15 @@ import { ArgToken } from "./parser.d-Cheh2e-O.js";
 * - `type` is not only 'string' and 'boolean', but also 'number' and 'enum' too.
 * - `default` property type, not support multiple types
 */
+/**
+* An option schema for an argument.
+* This schema is similar to the schema of the `node:utils`.
+* difference is that:
+* - `multiple` property is not supported
+* - `required` property and `description` property are added
+* - `type` is not only 'string' and 'boolean', but also 'number' and 'enum' too.
+* - `default` property type, not support multiple types
+*/
 interface ArgOptionSchema {
   /**
   * Type of argument.
@@ -34,39 +43,37 @@ interface ArgOptionSchema {
   /**
   * The allowed values of the argument, and string only. This property is only used when the type is 'enum'.
   */
-  choices?: string[];
+  choices?: string[] | readonly string[];
   /**
   * The default value of the argument.
   * if the type is 'enum', the default value must be one of the allowed values.
   */
   default?: string | boolean | number;
-} /**
-  * An object that contains {@link ArgOptionSchema | options schema}.
-  */
-
+}
+/**
+* An object that contains {@link ArgOptionSchema | options schema}.
+*/
 interface ArgOptions {
   [option: string]: ArgOptionSchema;
-} /**
-  * An object that contains the values of the arguments.
-  */
-
+}
+/**
+* An object that contains the values of the arguments.
+*/
 type ArgValues<T> = T extends ArgOptions ? ResolveArgValues<T, { [Option in keyof T]: ExtractOptionValue<T[Option]> }> : {
   [option: string]: string | boolean | number | undefined;
-}; /**
-   * @internal
-   */
-
-type ExtractOptionValue<O extends ArgOptionSchema> = O["type"] extends "string" ? string : O["type"] extends "boolean" ? boolean : O["type"] extends "number" ? number : O["type"] extends "enum" ? O["choices"] extends string[] ? O["choices"][number] : never : string | boolean | number; /**
-                                                                                                                                                                                                                                                                                              * @internal
-                                                                                                                                                                                                                                                                                              */
-
+};
+/**
+* @internal
+*/
+type ExtractOptionValue<O extends ArgOptionSchema> = O["type"] extends "string" ? string : O["type"] extends "boolean" ? boolean : O["type"] extends "number" ? number : O["type"] extends "enum" ? O["choices"] extends string[] | readonly string[] ? O["choices"][number] : never : string | boolean | number;
+/**
+* @internal
+*/
 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;
-
 /**
 * @internal
 */
 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] };
-
 /**
 * An options for {@link resolveArgs | resolve arguments}.
 */
@@ -78,7 +85,6 @@ interface ResolveArgsOptions {
   */
   optionGrouping?: boolean;
 }
-
 /**
 * Resolve command line arguments.
 * @param options - An options that contains {@link ArgOptionSchema | options schema}.
@@ -94,12 +100,10 @@ declare function resolveArgs<T extends ArgOptions>(options: T, tokens: ArgToken[
   rest: string[];
   error: AggregateError | undefined;
 };
-
 /**
 * An error type for {@link OptionResolveError}.
 */
 type OptionResolveErrorType = "type" | "required";
-
 /**
 * An error that occurs when resolving options.
 * This error is thrown when the option is not valid.

package/lib/resolver.d.ts

@@ -1,3 +1,3 @@
-import "./parser.d-Cheh2e-O.js";
-import { ArgOptionSchema, ArgOptions, ArgValues, ExtractOptionValue, FilterArgs, OptionResolveError$1 as OptionResolveError, OptionResolveErrorType, ResolveArgValues, ResolveArgsOptions, resolveArgs$1 as resolveArgs } from "./resolver.d-D6XfwWOY.js";
+import "./parser-Bx112mWZ.js";
+import { ArgOptionSchema, ArgOptions, ArgValues, ExtractOptionValue, FilterArgs, OptionResolveError$1 as OptionResolveError, OptionResolveErrorType, ResolveArgValues, ResolveArgsOptions, resolveArgs$1 as resolveArgs } from "./resolver-ByBRRKOK.js";
 export { ArgOptionSchema, ArgOptions, ArgValues, ExtractOptionValue, FilterArgs, OptionResolveError, OptionResolveErrorType, ResolveArgValues, ResolveArgsOptions, resolveArgs };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "args-tokens",
   "description": "parseArgs tokens compatibility and more high-performance parser",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "author": {
     "name": "kazuya kawaguchi",
     "email": "kawakazu80@gmail.com"
@@ -68,28 +68,28 @@
     "@eslint/markdown": "^6.4.0",
     "@kazupon/eslint-config": "^0.29.0",
     "@kazupon/prettier-config": "^0.1.1",
-    "@types/node": "^22.15.2",
-    "@vitest/eslint-plugin": "^1.1.43",
+    "@types/node": "^22.15.3",
+    "@vitest/eslint-plugin": "^1.1.44",
     "bumpp": "^10.1.0",
-    "deno": "^2.2.12",
-    "eslint": "^9.25.1",
+    "deno": "^2.3.1",
+    "eslint": "^9.26.0",
     "eslint-config-prettier": "^10.1.2",
     "eslint-plugin-jsonc": "^2.20.0",
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-regexp": "^2.7.0",
-    "eslint-plugin-unicorn": "^58.0.0",
+    "eslint-plugin-unicorn": "^59.0.0",
     "eslint-plugin-yml": "^1.18.0",
     "gh-changelogen": "^0.2.8",
     "jsr": "^0.13.4",
     "jsr-exports-lint": "^0.2.0",
-    "knip": "^5.50.5",
+    "knip": "^5.52.0",
     "lint-staged": "^15.5.1",
     "mitata": "^1.0.34",
     "pkg-pr-new": "^0.0.43",
     "prettier": "^3.5.3",
-    "tsdown": "^0.10.0",
+    "tsdown": "^0.10.2",
     "typescript": "^5.8.3",
-    "typescript-eslint": "^8.31.0",
+    "typescript-eslint": "^8.31.1",
     "vitest": "^3.1.2"
   },
   "prettier": "@kazupon/prettier-config",