@cli-forge/parser 0.6.0 → 0.8.0

package/src/lib/parsers/typings.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoValueError = void 0;
+class NoValueError extends Error {
+    constructor() {
+        super('Expected a value');
+    }
+}
+exports.NoValueError = NoValueError;
+//# sourceMappingURL=typings.js.map

package/src/lib/parsers/typings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typings.js","sourceRoot":"","sources":["../../../../../../packages/parser/src/lib/parsers/typings.ts"],"names":[],"mappings":";;;AAWA,MAAa,YAAa,SAAQ,KAAK;IACrC;QACE,KAAK,CAAC,kBAAkB,CAAC,CAAC;IAC5B,CAAC;CACF;AAJD,oCAIC"}

package/src/lib/{utils.js → utils/case-transformations.js}

@@ -43,4 +43,4 @@ function getEnvKey(prefix, key) {
         ? `${prefix}_${fromCamelOrDashedCaseToConstCase(key)}`
         : fromCamelOrDashedCaseToConstCase(key);
 }
-//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=case-transformations.js.map

package/src/lib/utils/case-transformations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"case-transformations.js","sourceRoot":"","sources":["../../../../../../packages/parser/src/lib/utils/case-transformations.ts"],"names":[],"mappings":";;AAAA,sDAEC;AAED,4EA+BC;AAED,8BAIC;AAzCD,SAAgB,qBAAqB,CAAC,GAAW;IAC/C,OAAO,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;AAC3E,CAAC;AAED,SAAgB,gCAAgC,CAAC,GAAW;IAC1D,MAAM,KAAK,GAAG,EAAE,CAAC;IACjB,IAAI,WAAW,GAAG,EAAE,CAAC;IACrB,IAAI,IAAwB,CAAC;IAC7B,KAAK,MAAM,IAAI,IAAI,GAAG,EAAE,CAAC;QACvB,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACjB,IAAI,WAAW,CAAC,MAAM,EAAE,CAAC;gBACvB,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC1B,CAAC;YACD,WAAW,GAAG,EAAE,CAAC;YACjB,SAAS;QACX,CAAC;QACD,oDAAoD;QACpD,IAAI,IAAI,IAAI,IAAI,EAAE,WAAW,EAAE,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;YACxE,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YACxB,WAAW,GAAG,IAAI,CAAC;YACnB,sCAAsC;QACxC,CAAC;aAAM,IACL,IAAI,EAAE,WAAW,EAAE,KAAK,IAAI;YAC5B,IAAI,KAAK,IAAI,CAAC,WAAW,EAAE;YAC3B,WAAW,CAAC,MAAM,GAAG,CAAC,EACtB,CAAC;YACD,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YACrC,WAAW,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QAC7C,CAAC;aAAM,CAAC;YACN,WAAW,IAAI,IAAI,CAAC;QACtB,CAAC;QACD,IAAI,GAAG,IAAI,CAAC;IACd,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACxB,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;AACvC,CAAC;AAED,SAAgB,SAAS,CAAC,MAA0B,EAAE,GAAW;IAC/D,OAAO,MAAM;QACX,CAAC,CAAC,GAAG,MAAM,IAAI,gCAAgC,CAAC,GAAG,CAAC,EAAE;QACtD,CAAC,CAAC,gCAAgC,CAAC,GAAG,CAAC,CAAC;AAC5C,CAAC"}

package/src/lib/utils/chain.d.ts

@@ -0,0 +1,316 @@
+import { OptionConfig } from '../option-types';
+import { ArgvParser, ParsedArgs } from '../parser';
+type UnaryFunction<T, R> = (arg: T) => R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, R>(initial: T0, fn0: UnaryFunction<T0, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, T2, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, T2>, fn2: UnaryFunction<T2, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, T2, T3, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, T2>, fn2: UnaryFunction<T2, T3>, fn3: UnaryFunction<T3, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, T2, T3, T4, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, T2>, fn2: UnaryFunction<T2, T3>, fn3: UnaryFunction<T3, T4>, fn4: UnaryFunction<T4, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, T2, T3, T4, T5, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, T2>, fn2: UnaryFunction<T2, T3>, fn3: UnaryFunction<T3, T4>, fn4: UnaryFunction<T4, T5>, fn5: UnaryFunction<T5, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, T2, T3, T4, T5, T6, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, T2>, fn2: UnaryFunction<T2, T3>, fn3: UnaryFunction<T3, T4>, fn4: UnaryFunction<T4, T5>, fn5: UnaryFunction<T5, T6>, fn6: UnaryFunction<T6, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, T2, T3, T4, T5, T6, T7, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, T2>, fn2: UnaryFunction<T2, T3>, fn3: UnaryFunction<T3, T4>, fn4: UnaryFunction<T4, T5>, fn5: UnaryFunction<T5, T6>, fn6: UnaryFunction<T6, T7>, fn7: UnaryFunction<T7, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, T2, T3, T4, T5, T6, T7, T8, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, T2>, fn2: UnaryFunction<T2, T3>, fn3: UnaryFunction<T3, T4>, fn4: UnaryFunction<T4, T5>, fn5: UnaryFunction<T5, T6>, fn6: UnaryFunction<T6, T7>, fn7: UnaryFunction<T7, T8>, fn8: UnaryFunction<T8, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, T2>, fn2: UnaryFunction<T2, T3>, fn3: UnaryFunction<T3, T4>, fn4: UnaryFunction<T4, T5>, fn5: UnaryFunction<T5, T6>, fn6: UnaryFunction<T6, T7>, fn7: UnaryFunction<T7, T8>, fn8: UnaryFunction<T8, T9>, fn9: UnaryFunction<T9, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, T2>, fn2: UnaryFunction<T2, T3>, fn3: UnaryFunction<T3, T4>, fn4: UnaryFunction<T4, T5>, fn5: UnaryFunction<T5, T6>, fn6: UnaryFunction<T6, T7>, fn7: UnaryFunction<T7, T8>, fn8: UnaryFunction<T8, T9>, fn9: UnaryFunction<T9, T10>, fn10: UnaryFunction<T10, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, T2>, fn2: UnaryFunction<T2, T3>, fn3: UnaryFunction<T3, T4>, fn4: UnaryFunction<T4, T5>, fn5: UnaryFunction<T5, T6>, fn6: UnaryFunction<T6, T7>, fn7: UnaryFunction<T7, T8>, fn8: UnaryFunction<T8, T9>, fn9: UnaryFunction<T9, T10>, fn10: UnaryFunction<T10, T11>, fn11: UnaryFunction<T11, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, T2>, fn2: UnaryFunction<T2, T3>, fn3: UnaryFunction<T3, T4>, fn4: UnaryFunction<T4, T5>, fn5: UnaryFunction<T5, T6>, fn6: UnaryFunction<T6, T7>, fn7: UnaryFunction<T7, T8>, fn8: UnaryFunction<T8, T9>, fn9: UnaryFunction<T9, T10>, fn10: UnaryFunction<T10, T11>, fn11: UnaryFunction<T11, T12>, fn12: UnaryFunction<T12, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, T2>, fn2: UnaryFunction<T2, T3>, fn3: UnaryFunction<T3, T4>, fn4: UnaryFunction<T4, T5>, fn5: UnaryFunction<T5, T6>, fn6: UnaryFunction<T6, T7>, fn7: UnaryFunction<T7, T8>, fn8: UnaryFunction<T8, T9>, fn9: UnaryFunction<T9, T10>, fn10: UnaryFunction<T10, T11>, fn11: UnaryFunction<T11, T12>, fn12: UnaryFunction<T12, T13>, fn13: UnaryFunction<T13, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, T2>, fn2: UnaryFunction<T2, T3>, fn3: UnaryFunction<T3, T4>, fn4: UnaryFunction<T4, T5>, fn5: UnaryFunction<T5, T6>, fn6: UnaryFunction<T6, T7>, fn7: UnaryFunction<T7, T8>, fn8: UnaryFunction<T8, T9>, fn9: UnaryFunction<T9, T10>, fn10: UnaryFunction<T10, T11>, fn11: UnaryFunction<T11, T12>, fn12: UnaryFunction<T12, T13>, fn13: UnaryFunction<T13, T14>, fn14: UnaryFunction<T14, R>): R;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+export declare function chain<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R>(initial: T0, fn0: UnaryFunction<T0, T1>, fn1: UnaryFunction<T1, T2>, fn2: UnaryFunction<T2, T3>, fn3: UnaryFunction<T3, T4>, fn4: UnaryFunction<T4, T5>, fn5: UnaryFunction<T5, T6>, fn6: UnaryFunction<T6, T7>, fn7: UnaryFunction<T7, T8>, fn8: UnaryFunction<T8, T9>, fn9: UnaryFunction<T9, T10>, fn10: UnaryFunction<T10, T11>, fn11: UnaryFunction<T11, T12>, fn12: UnaryFunction<T12, T13>, fn13: UnaryFunction<T13, T14>, fn14: UnaryFunction<T14, T15>, fn15: UnaryFunction<T15, R>): R;
+/**
+ * A composition helper to be used with {@link chain}.
+ *
+ * @param name The name of the option to add
+ * @param config The configuration for the option
+ * @returns A unary function that adds an option to an {@link ArgvParser}.
+ */
+export declare function makeComposableOption<const TKey extends string, const TOptionConfig extends OptionConfig>(name: TKey, config: TOptionConfig): <const T extends ParsedArgs>(argv: ArgvParser<T>) => ArgvParser<T & { [key in TKey]: import("../option-types").OptionConfigToType<TOptionConfig>; }>;
+export {};

package/src/lib/utils/chain.js

@@ -0,0 +1,54 @@
+"use strict";
+// This file pains me quite a bit. Before any feedback is given, consider the following:
+// - There is currently no way to infer the types of a `...rest` parameter individually.
+// - This is how rxjs does it, and that's because its really the only way in current TS / JS
+//   - See: https://github.com/ReactiveX/rxjs/blob/master/packages%2Fobservable%2Fsrc%2Fobservable.ts#L788
+// - This isn't maintained or even written by hand, aside from the final implementation. The various
+//   overload signatures are copilot generated.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chain = chain;
+exports.makeComposableOption = makeComposableOption;
+/**
+ * Applies a series of functions to an initial value, passing the result of each function to the next.
+ *
+ * Used to convert code that looks like:
+ * ```typescript
+ * const a = addB(addC({ a: 'a' }));
+ * ```
+ * to:
+ * ```typescript
+ * const a = chain({ a: 'a' }, addB, addC);
+ * ```
+ *
+ * See [composable-options](/examples/composable-options) for an example of how this can be used.
+ *
+ * NOTE: Seeing a return type of `unknown`? This is likely due to the number of functions passed to
+ * `chain` exceeding the number of overloads provided. There is a technical limitation in TypeScript
+ * that means we need to provide a finite number of overloads. While we anticipate that 16 overloads
+ * should be enough for most use cases, if you need more you can combine chains together like below:
+ * ```typescript
+ * const a = chain(
+ *    { a: 'a' },
+ *   addB,
+ *   (iv) => chain(iv, addC, addD, addE),
+ * );
+ * ```
+ *
+ * @param initial Initial value to pass through the chain
+ * @param fns Functions to apply to the initial value, and each subsequent value
+ * @returns Updated value after all functions have been applied
+ */
+function chain(initial, ...fns) {
+    return fns.reduce((acc, fn) => fn(acc), initial);
+}
+/**
+ * A composition helper to be used with {@link chain}.
+ *
+ * @param name The name of the option to add
+ * @param config The configuration for the option
+ * @returns A unary function that adds an option to an {@link ArgvParser}.
+ */
+function makeComposableOption(name, config) {
+    return (argv) => argv.option(name, config);
+}
+//# sourceMappingURL=chain.js.map

package/src/lib/utils/chain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.js","sourceRoot":"","sources":["../../../../../../packages/parser/src/lib/utils/chain.ts"],"names":[],"mappings":";AAAA,wFAAwF;AACxF,wFAAwF;AACxF,4FAA4F;AAC5F,0GAA0G;AAC1G,oGAAoG;AACpG,+CAA+C;;AA6jB/C,sBAKC;AASD,oDAMC;AAlDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,SAAgB,KAAK,CACnB,OAAW,EACX,GAAG,GAA8B;IAEjC,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;AACnD,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,oBAAoB,CAGlC,IAAU,EAAE,MAAqB;IACjC,OAAO,CAA6B,IAAmB,EAAE,EAAE,CACzD,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AAC9B,CAAC"}

package/src/lib/utils/flags.d.ts

@@ -0,0 +1,3 @@
+export declare function isFlag(str: string): str is `-${string}`;
+export declare function readArgKeys(str: `-${string}`): string[];
+export declare function isNextFlag(str: string): boolean;

package/src/lib/utils/flags.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFlag = isFlag;
+exports.readArgKeys = readArgKeys;
+exports.isNextFlag = isNextFlag;
+const case_transformations_1 = require("./case-transformations");
+function isFlag(str) {
+    return str.startsWith('-');
+}
+function readArgKeys(str) {
+    // Long flags (e.g. --foo)
+    if (str.startsWith('--')) {
+        const key = str.slice(2);
+        if (key.includes('-')) {
+            return [(0, case_transformations_1.fromDashedToCamelCase)(key)];
+        }
+        return [str.slice(2)];
+        // Short flag combinations (e.g. -xvf)
+    }
+    else if (str.startsWith('-')) {
+        return str.slice(1).split('');
+    }
+    throw new Error(`Invalid flag ${str}`);
+}
+function isNextFlag(str) {
+    return str.startsWith('--') || str.startsWith('-');
+}
+//# sourceMappingURL=flags.js.map

package/src/lib/utils/flags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags.js","sourceRoot":"","sources":["../../../../../../packages/parser/src/lib/utils/flags.ts"],"names":[],"mappings":";;AAEA,wBAEC;AACD,kCAaC;AACD,gCAEC;AArBD,iEAA+D;AAE/D,SAAgB,MAAM,CAAC,GAAW;IAChC,OAAO,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC;AACD,SAAgB,WAAW,CAAC,GAAiB;IAC3C,0BAA0B;IAC1B,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACzB,MAAM,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACzB,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACtB,OAAO,CAAC,IAAA,4CAAqB,EAAC,GAAG,CAAC,CAAC,CAAC;QACtC,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACtB,sCAAsC;IACxC,CAAC;SAAM,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QAC/B,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAChC,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,gBAAgB,GAAG,EAAE,CAAC,CAAC;AACzC,CAAC;AACD,SAAgB,UAAU,CAAC,GAAW;IACpC,OAAO,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;AACrD,CAAC"}

package/src/lib/utils/get-configured-key.d.ts

@@ -0,0 +1,3 @@
+import { OptionConfig } from '../option-types';
+import { ParsedArgs } from '../parser';
+export declare function getConfiguredOptionKey<T extends ParsedArgs>(key: string, configuredOptions: Partial<Record<keyof T, OptionConfig>>): keyof T | undefined;

package/src/lib/utils/get-configured-key.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfiguredOptionKey = getConfiguredOptionKey;
+function getConfiguredOptionKey(key, configuredOptions) {
+    if (key in configuredOptions) {
+        return key;
+    }
+    function normalizeNegatedBooleanKey(key) {
+        if (key.startsWith('no') &&
+            key.length > 2 &&
+            key[2] === key[2].toUpperCase()) {
+            const stripped = key.slice(2);
+            return [stripped[0].toLowerCase(), stripped.slice(1)].join('');
+        }
+        return key;
+    }
+    function normalizeObjectOptionKey(key) {
+        if (key.includes('.')) {
+            return key.split('.')[0];
+        }
+        return key;
+    }
+    // Handles booleans passed as `--no-foo`
+    const normalizedKey = normalizeObjectOptionKey(normalizeNegatedBooleanKey(key));
+    if (normalizedKey in configuredOptions) {
+        return normalizedKey;
+    }
+    for (const configuredKey in configuredOptions) {
+        const config = configuredOptions[configuredKey];
+        if (config?.alias?.includes(key)) {
+            return configuredKey;
+        }
+        // Handles negated booleans that are aliased
+        if (config?.type === 'boolean' && config.alias?.includes(normalizedKey)) {
+            return configuredKey;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=get-configured-key.js.map

package/src/lib/utils/get-configured-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-configured-key.js","sourceRoot":"","sources":["../../../../../../packages/parser/src/lib/utils/get-configured-key.ts"],"names":[],"mappings":";;AAGA,wDA+CC;AA/CD,SAAgB,sBAAsB,CACpC,GAAW,EACX,iBAAyD;IAEzD,IAAI,GAAG,IAAI,iBAAiB,EAAE,CAAC;QAC7B,OAAO,GAAc,CAAC;IACxB,CAAC;IAED,SAAS,0BAA0B,CAAC,GAAW;QAC7C,IACE,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC;YACpB,GAAG,CAAC,MAAM,GAAG,CAAC;YACd,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,EAC/B,CAAC;YACD,MAAM,QAAQ,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC9B,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACjE,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,SAAS,wBAAwB,CAAC,GAAW;QAC3C,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACtB,OAAO,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,wCAAwC;IACxC,MAAM,aAAa,GAAG,wBAAwB,CAC5C,0BAA0B,CAAC,GAAG,CAAC,CAChC,CAAC;IAEF,IAAI,aAAa,IAAI,iBAAiB,EAAE,CAAC;QACvC,OAAO,aAAwB,CAAC;IAClC,CAAC;IAED,KAAK,MAAM,aAAa,IAAI,iBAAiB,EAAE,CAAC;QAC9C,MAAM,MAAM,GAAG,iBAAiB,CAAC,aAAa,CAAC,CAAC;QAChD,IAAI,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACjC,OAAO,aAAwB,CAAC;QAClC,CAAC;QACD,4CAA4C;QAC5C,IAAI,MAAM,EAAE,IAAI,KAAK,SAAS,IAAI,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;YACxE,OAAO,aAAwB,CAAC;QAClC,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/src/lib/utils/read-default-value.d.ts

@@ -0,0 +1,2 @@
+import { OptionConfig, OptionConfigToType } from '../option-types';
+export declare function readDefaultValue<const T extends OptionConfig>(option: T): [OptionConfigToType<T> | undefined, string | undefined];

package/src/lib/utils/read-default-value.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDefaultValue = readDefaultValue;
+function readDefaultValue(option) {
+    if (option.default !== undefined) {
+        const declaredDefault = option.default;
+        if (typeof declaredDefault === 'object') {
+            if ('value' in declaredDefault) {
+                const value = declaredDefault.value;
+                return [value, declaredDefault.description];
+            }
+            if ('factory' in declaredDefault) {
+                const factory = declaredDefault.factory;
+                return [factory(), declaredDefault.description];
+            }
+        }
+        else {
+            return [declaredDefault, undefined];
+        }
+    }
+    return [undefined, undefined];
+}
+//# sourceMappingURL=read-default-value.js.map

package/src/lib/utils/read-default-value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-default-value.js","sourceRoot":"","sources":["../../../../../../packages/parser/src/lib/utils/read-default-value.ts"],"names":[],"mappings":";;AAOA,4CAoBC;AApBD,SAAgB,gBAAgB,CAC9B,MAAS;IAET,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QACjC,MAAM,eAAe,GAAG,MAAM,CAAC,OAA4B,CAAC;QAC5D,IAAI,OAAO,eAAe,KAAK,QAAQ,EAAE,CAAC;YACxC,IAAI,OAAO,IAAI,eAAe,EAAE,CAAC;gBAC/B,MAAM,KAAK,GAAG,eAAe,CAAC,KAAqC,CAAC;gBACpE,OAAO,CAAC,KAAK,EAAE,eAAe,CAAC,WAAW,CAAC,CAAC;YAC9C,CAAC;YACD,IAAI,SAAS,IAAI,eAAe,EAAE,CAAC;gBACjC,MAAM,OAAO,GACX,eAAe,CAAC,OAA6C,CAAC;gBAChE,OAAO,CAAC,OAAO,EAAE,EAAE,eAAe,CAAC,WAAW,CAAC,CAAC;YAClD,CAAC;QACH,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;IACD,OAAO,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;AAChC,CAAC"}

package/src/lib/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../packages/parser/src/lib/utils.ts"],"names":[],"mappings":";;AAAA,sDAEC;AAED,4EA+BC;AAED,8BAIC;AAzCD,SAAgB,qBAAqB,CAAC,GAAW;IAC/C,OAAO,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;AAC3E,CAAC;AAED,SAAgB,gCAAgC,CAAC,GAAW;IAC1D,MAAM,KAAK,GAAG,EAAE,CAAC;IACjB,IAAI,WAAW,GAAG,EAAE,CAAC;IACrB,IAAI,IAAwB,CAAC;IAC7B,KAAK,MAAM,IAAI,IAAI,GAAG,EAAE,CAAC;QACvB,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACjB,IAAI,WAAW,CAAC,MAAM,EAAE,CAAC;gBACvB,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC1B,CAAC;YACD,WAAW,GAAG,EAAE,CAAC;YACjB,SAAS;QACX,CAAC;QACD,oDAAoD;QACpD,IAAI,IAAI,IAAI,IAAI,EAAE,WAAW,EAAE,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;YACxE,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YACxB,WAAW,GAAG,IAAI,CAAC;YACnB,sCAAsC;QACxC,CAAC;aAAM,IACL,IAAI,EAAE,WAAW,EAAE,KAAK,IAAI;YAC5B,IAAI,KAAK,IAAI,CAAC,WAAW,EAAE;YAC3B,WAAW,CAAC,MAAM,GAAG,CAAC,EACtB,CAAC;YACD,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YACrC,WAAW,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QAC7C,CAAC;aAAM,CAAC;YACN,WAAW,IAAI,IAAI,CAAC;QACtB,CAAC;QACD,IAAI,GAAG,IAAI,CAAC;IACd,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACxB,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;AACvC,CAAC;AAED,SAAgB,SAAS,CAAC,MAA0B,EAAE,GAAW;IAC/D,OAAO,MAAM;QACX,CAAC,CAAC,GAAG,MAAM,IAAI,gCAAgC,CAAC,GAAG,CAAC,EAAE;QACtD,CAAC,CAAC,gCAAgC,CAAC,GAAG,CAAC,CAAC;AAC5C,CAAC"}