jackspeak 4.0.0 → 4.0.2

package/dist/commonjs/index.js

@@ -3,23 +3,61 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jack = exports.Jack = exports.isConfigOption = exports.isConfigType = void 0;
+exports.jack = exports.Jack = exports.isConfigOption = exports.isConfigOptionOfType = exports.isConfigType = void 0;
 const node_util_1 = require("node:util");
-const parse_args_js_1 = require("./parse-args.js");
 // it's a tiny API, just cast it inline, it's fine
 //@ts-ignore
 const cliui_1 = __importDefault(require("@isaacs/cliui"));
 const node_path_1 = require("node:path");
-const width = Math.min((process && process.stdout && process.stdout.columns) || 80, 80);
+const isConfigType = (t) => typeof t === 'string' &&
+    (t === 'string' || t === 'number' || t === 'boolean');
+exports.isConfigType = isConfigType;
+const isValidValue = (v, type, multi) => {
+    if (multi) {
+        if (!Array.isArray(v))
+            return false;
+        return !v.some((v) => !isValidValue(v, type, false));
+    }
+    if (Array.isArray(v))
+        return false;
+    return typeof v === type;
+};
+const isValidOption = (v, vo) => !!vo &&
+    (Array.isArray(v) ? v.every(x => isValidOption(x, vo)) : vo.includes(v));
+/**
+ * Determine whether an unknown object is a {@link ConfigOption} based only
+ * on its `type` and `multiple` property
+ */
+const isConfigOptionOfType = (o, type, multi) => !!o &&
+    typeof o === 'object' &&
+    (0, exports.isConfigType)(o.type) &&
+    o.type === type &&
+    !!o.multiple === multi;
+exports.isConfigOptionOfType = isConfigOptionOfType;
+/**
+ * Determine whether an unknown object is a {@link ConfigOption} based on
+ * it having all valid properties
+ */
+const isConfigOption = (o, type, multi) => (0, exports.isConfigOptionOfType)(o, type, multi) &&
+    undefOrType(o.short, 'string') &&
+    undefOrType(o.description, 'string') &&
+    undefOrType(o.hint, 'string') &&
+    undefOrType(o.validate, 'function') &&
+    (o.type === 'boolean' ?
+        o.validOptions === undefined
+        : undefOrTypeArray(o.validOptions, o.type)) &&
+    (o.default === undefined || isValidValue(o.default, type, multi));
+exports.isConfigOption = isConfigOption;
+const isHeading = (r) => r.type === 'heading';
+const isDescription = (r) => r.type === 'description';
+const width = Math.min(process?.stdout?.columns ?? 80, 80);
 // indentation spaces from heading level
 const indent = (n) => (n - 1) * 2;
-const toEnvKey = (pref, key) => {
-    return [pref, key.replace(/[^a-zA-Z0-9]+/g, ' ')]
-        .join(' ')
-        .trim()
-        .toUpperCase()
-        .replace(/ /g, '_');
-};
+const toEnvKey = (pref, key) => [pref, key.replace(/[^a-zA-Z0-9]+/g, ' ')]
+    .join(' ')
+    .trim()
+    .toUpperCase()
+    .replace(/ /g, '_');
 const toEnvVal = (value, delim = '\n') => {
     const str = typeof value === 'string' ? value
         : typeof value === 'boolean' ?
@@ -41,256 +79,144 @@ const fromEnvVal = (env, type, multiple, delim = '\n') => (multiple ?
     : type === 'string' ? env
         : type === 'boolean' ? env === '1'
             : +env.trim());
-const isConfigType = (t) => typeof t === 'string' &&
-    (t === 'string' || t === 'number' || t === 'boolean');
-exports.isConfigType = isConfigType;
 const undefOrType = (v, t) => v === undefined || typeof v === t;
 const undefOrTypeArray = (v, t) => v === undefined || (Array.isArray(v) && v.every(x => typeof x === t));
-const isValidOption = (v, vo) => Array.isArray(v) ? v.every(x => isValidOption(x, vo)) : vo.includes(v);
 // print the value type, for error message reporting
 const valueType = (v) => typeof v === 'string' ? 'string'
     : typeof v === 'boolean' ? 'boolean'
         : typeof v === 'number' ? 'number'
             : Array.isArray(v) ?
-                joinTypes([...new Set(v.map(v => valueType(v)))]) + '[]'
+                `${joinTypes([...new Set(v.map(v => valueType(v)))])}[]`
                 : `${v.type}${v.multiple ? '[]' : ''}`;
 const joinTypes = (types) => types.length === 1 && typeof types[0] === 'string' ?
     types[0]
     : `(${types.join('|')})`;
-const isValidValue = (v, type, multi) => {
-    if (multi) {
-        if (!Array.isArray(v))
-            return false;
-        return !v.some((v) => !isValidValue(v, type, false));
-    }
-    if (Array.isArray(v))
-        return false;
-    return typeof v === type;
-};
-const isConfigOption = (o, type, multi) => !!o &&
-    typeof o === 'object' &&
-    (0, exports.isConfigType)(o.type) &&
-    o.type === type &&
-    undefOrType(o.short, 'string') &&
-    undefOrType(o.description, 'string') &&
-    undefOrType(o.hint, 'string') &&
-    undefOrType(o.validate, 'function') &&
-    (o.type === 'boolean' ?
-        o.validOptions === undefined
-        : undefOrTypeArray(o.validOptions, o.type)) &&
-    (o.default === undefined || isValidValue(o.default, type, multi)) &&
-    !!o.multiple === multi;
-exports.isConfigOption = isConfigOption;
-function num(o = {}) {
-    const { default: def, validate: val, validOptions, ...rest } = o;
-    if (def !== undefined && !isValidValue(def, 'number', false)) {
-        throw new TypeError('invalid default value', {
-            cause: {
-                found: def,
-                wanted: 'number',
-            },
-        });
-    }
-    if (!undefOrTypeArray(validOptions, 'number')) {
-        throw new TypeError('invalid validOptions', {
-            cause: {
-                found: validOptions,
-                wanted: 'number[]',
-            },
-        });
-    }
-    const validate = val ?
-        val
-        : undefined;
-    return {
-        ...rest,
-        default: def,
-        validate,
-        validOptions,
-        type: 'number',
-        multiple: false,
-    };
-}
-function numList(o = {}) {
-    const { default: def, validate: val, validOptions, ...rest } = o;
-    if (def !== undefined && !isValidValue(def, 'number', true)) {
-        throw new TypeError('invalid default value', {
-            cause: {
-                found: def,
-                wanted: 'number[]',
-            },
-        });
+const validateFieldMeta = (field, fieldMeta) => {
+    if (fieldMeta) {
+        if (field.type !== undefined && field.type !== fieldMeta.type) {
+            throw new TypeError(`invalid type`, {
+                cause: {
+                    found: field.type,
+                    wanted: [fieldMeta.type, undefined],
+                },
+            });
+        }
+        if (field.multiple !== undefined &&
+            !!field.multiple !== fieldMeta.multiple) {
+            throw new TypeError(`invalid multiple`, {
+                cause: {
+                    found: field.multiple,
+                    wanted: [fieldMeta.multiple, undefined],
+                },
+            });
+        }
+        return fieldMeta;
     }
-    if (!undefOrTypeArray(validOptions, 'number')) {
-        throw new TypeError('invalid validOptions', {
+    if (!(0, exports.isConfigType)(field.type)) {
+        throw new TypeError(`invalid type`, {
             cause: {
-                found: validOptions,
-                wanted: 'number[]',
+                found: field.type,
+                wanted: ['string', 'number', 'boolean'],
             },
         });
     }
-    const validate = val ?
-        val
-        : undefined;
     return {
-        ...rest,
-        default: def,
-        validate,
-        validOptions,
-        type: 'number',
-        multiple: true,
+        type: field.type,
+        multiple: !!field.multiple,
     };
-}
-function opt(o = {}) {
-    const { default: def, validate: val, validOptions, ...rest } = o;
-    if (def !== undefined && !isValidValue(def, 'string', false)) {
-        throw new TypeError('invalid default value', {
-            cause: {
-                found: def,
-                wanted: 'string',
-            },
-        });
-    }
-    if (!undefOrTypeArray(validOptions, 'string')) {
-        throw new TypeError('invalid validOptions', {
-            cause: {
-                found: validOptions,
-                wanted: 'string[]',
-            },
-        });
-    }
-    const validate = val ?
-        val
-        : undefined;
-    return {
-        ...rest,
-        default: def,
-        validate,
-        validOptions,
-        type: 'string',
-        multiple: false,
+};
+const validateField = (o, type, multiple) => {
+    const validateValidOptions = (def, validOptions) => {
+        if (!undefOrTypeArray(validOptions, type)) {
+            throw new TypeError('invalid validOptions', {
+                cause: {
+                    found: validOptions,
+                    wanted: valueType({ type, multiple: true }),
+                },
+            });
+        }
+        if (def !== undefined && validOptions !== undefined) {
+            const valid = Array.isArray(def) ?
+                def.every(v => validOptions.includes(v))
+                : validOptions.includes(def);
+            if (!valid) {
+                throw new TypeError('invalid default value not in validOptions', {
+                    cause: {
+                        found: def,
+                        wanted: validOptions,
+                    },
+                });
+            }
+        }
     };
-}
-function optList(o = {}) {
-    const { default: def, validate: val, validOptions, ...rest } = o;
-    if (def !== undefined && !isValidValue(def, 'string', true)) {
+    if (o.default !== undefined &&
+        !isValidValue(o.default, type, multiple)) {
         throw new TypeError('invalid default value', {
             cause: {
-                found: def,
-                wanted: 'string[]',
+                found: o.default,
+                wanted: valueType({ type, multiple }),
             },
         });
     }
-    if (!undefOrTypeArray(validOptions, 'string')) {
-        throw new TypeError('invalid validOptions', {
-            cause: {
-                found: validOptions,
-                wanted: 'string[]',
-            },
-        });
+    if ((0, exports.isConfigOptionOfType)(o, 'number', false) ||
+        (0, exports.isConfigOptionOfType)(o, 'number', true)) {
+        validateValidOptions(o.default, o.validOptions);
     }
-    const validate = val ?
-        val
-        : undefined;
-    return {
-        ...rest,
-        default: def,
-        validate,
-        validOptions,
-        type: 'string',
-        multiple: true,
-    };
-}
-function flag(o = {}) {
-    const { hint, default: def, validate: val, ...rest } = o;
-    delete rest.validOptions;
-    if (def !== undefined && !isValidValue(def, 'boolean', false)) {
-        throw new TypeError('invalid default value');
-    }
-    const validate = val ?
-        val
-        : undefined;
-    if (hint !== undefined) {
-        throw new TypeError('cannot provide hint for flag');
+    else if ((0, exports.isConfigOptionOfType)(o, 'string', false) ||
+        (0, exports.isConfigOptionOfType)(o, 'string', true)) {
+        validateValidOptions(o.default, o.validOptions);
     }
-    return {
-        ...rest,
-        default: def,
-        validate,
-        type: 'boolean',
-        multiple: false,
-    };
-}
-function flagList(o = {}) {
-    const { hint, default: def, validate: val, ...rest } = o;
-    delete rest.validOptions;
-    if (def !== undefined && !isValidValue(def, 'boolean', true)) {
-        throw new TypeError('invalid default value');
-    }
-    const validate = val ?
-        val
-        : undefined;
-    if (hint !== undefined) {
-        throw new TypeError('cannot provide hint for flag list');
+    else if ((0, exports.isConfigOptionOfType)(o, 'boolean', false) ||
+        (0, exports.isConfigOptionOfType)(o, 'boolean', true)) {
+        if (o.hint !== undefined) {
+            throw new TypeError('cannot provide hint for flag');
+        }
+        if (o.validOptions !== undefined) {
+            throw new TypeError('cannot provide validOptions for flag');
+        }
     }
-    return {
-        ...rest,
-        default: def,
-        validate,
-        type: 'boolean',
-        multiple: true,
-    };
-}
+    return o;
+};
 const toParseArgsOptionsConfig = (options) => {
-    const c = {};
-    for (const longOption in options) {
-        const config = options[longOption];
-        /* c8 ignore start */
-        if (!config) {
-            throw new Error('config must be an object: ' + longOption);
-        }
-        /* c8 ignore start */
-        if ((0, exports.isConfigOption)(config, 'number', true)) {
-            c[longOption] = {
-                type: 'string',
-                multiple: true,
-                default: config.default?.map(c => String(c)),
-            };
-        }
-        else if ((0, exports.isConfigOption)(config, 'number', false)) {
-            c[longOption] = {
-                type: 'string',
-                multiple: false,
-                default: config.default === undefined ?
-                    undefined
-                    : String(config.default),
-            };
+    return Object.entries(options).reduce((acc, [longOption, o]) => {
+        const p = {
+            type: 'string',
+            multiple: !!o.multiple,
+            ...(typeof o.short === 'string' ? { short: o.short } : undefined),
+        };
+        const setNoBool = () => {
+            if (!longOption.startsWith('no-') && !options[`no-${longOption}`]) {
+                acc[`no-${longOption}`] = {
+                    type: 'boolean',
+                    multiple: !!o.multiple,
+                };
+            }
+        };
+        const setDefault = (def, fn) => {
+            if (def !== undefined) {
+                p.default = fn(def);
+            }
+        };
+        if ((0, exports.isConfigOption)(o, 'number', false)) {
+            setDefault(o.default, String);
         }
-        else {
-            const conf = config;
-            c[longOption] = {
-                type: conf.type,
-                multiple: !!conf.multiple,
-                default: conf.default,
-            };
-        }
-        const clo = c[longOption];
-        if (typeof config.short === 'string') {
-            clo.short = config.short;
-        }
-        if (config.type === 'boolean' &&
-            !longOption.startsWith('no-') &&
-            !options[`no-${longOption}`]) {
-            c[`no-${longOption}`] = {
-                type: 'boolean',
-                multiple: config.multiple,
-            };
-        }
-    }
-    return c;
+        else if ((0, exports.isConfigOption)(o, 'number', true)) {
+            setDefault(o.default, d => d.map(v => String(v)));
+        }
+        else if ((0, exports.isConfigOption)(o, 'string', false) ||
+            (0, exports.isConfigOption)(o, 'string', true)) {
+            setDefault(o.default, v => v);
+        }
+        else if ((0, exports.isConfigOption)(o, 'boolean', false) ||
+            (0, exports.isConfigOption)(o, 'boolean', true)) {
+            p.type = 'boolean';
+            setDefault(o.default, v => v);
+            setNoBool();
+        }
+        acc[longOption] = p;
+        return acc;
+    }, {});
 };
-const isHeading = (r) => r.type === 'heading';
-const isDescription = (r) => r.type === 'description';
 /**
  * Class returned by the {@link jack} function and all configuration
  * definition methods.  This is what gets chained together.
@@ -328,16 +254,12 @@ class Jack {
             this.validate(values);
         }
         catch (er) {
-            const e = er;
-            if (source && e && typeof e === 'object') {
-                if (e.cause && typeof e.cause === 'object') {
-                    Object.assign(e.cause, { path: source });
-                }
-                else {
-                    e.cause = { path: source };
-                }
+            if (source && er instanceof Error) {
+                /* c8 ignore next */
+                const cause = typeof er.cause === 'object' ? er.cause : {};
+                er.cause = { ...cause, path: source };
             }
-            throw e;
+            throw er;
         }
         for (const [field, value] of Object.entries(values)) {
             const my = this.#configSet[field];
@@ -400,10 +322,9 @@ class Jack {
         if (args === process.argv) {
             args = args.slice(process._eval !== undefined ? 1 : 2);
         }
-        const options = toParseArgsOptionsConfig(this.#configSet);
-        const result = (0, parse_args_js_1.parseArgs)({
+        const result = (0, node_util_1.parseArgs)({
             args,
-            options,
+            options: toParseArgsOptionsConfig(this.#configSet),
             // always strict, but using our own logic
             strict: false,
             allowPositionals: this.#allowPositionals,
@@ -496,13 +417,10 @@ class Jack {
         for (const [field, value] of Object.entries(p.values)) {
             const valid = this.#configSet[field]?.validate;
             const validOptions = this.#configSet[field]?.validOptions;
-            let cause;
-            if (validOptions && !isValidOption(value, validOptions)) {
-                cause = { name: field, found: value, validOptions: validOptions };
-            }
-            if (valid && !valid(value)) {
-                cause = cause || { name: field, found: value };
-            }
+            const cause = validOptions && !isValidOption(value, validOptions) ?
+                { name: field, found: value, validOptions: validOptions }
+                : valid && !valid(value) ? { name: field, found: value }
+                    : undefined;
             if (cause) {
                 throw new Error(`Invalid value provided for --${field}: ${JSON.stringify(value)}`, { cause });
             }
@@ -555,18 +473,11 @@ class Jack {
                     },
                 });
             }
-            let cause;
-            if (config.validOptions &&
-                !isValidOption(value, config.validOptions)) {
-                cause = {
-                    name: field,
-                    found: value,
-                    validOptions: config.validOptions,
-                };
-            }
-            if (config.validate && !config.validate(value)) {
-                cause = cause || { name: field, found: value };
-            }
+            const cause = config.validOptions && !isValidOption(value, config.validOptions) ?
+                { name: field, found: value, validOptions: config.validOptions }
+                : config.validate && !config.validate(value) ?
+                    { name: field, found: value }
+                    : undefined;
             if (cause) {
                 throw new Error(`Invalid config value for ${field}: ${value}`, {
                     cause,
@@ -603,37 +514,37 @@ class Jack {
      * Add one or more number fields.
      */
     num(fields) {
-        return this.#addFields(fields, num);
+        return this.#addFieldsWith(fields, 'number', false);
     }
     /**
      * Add one or more multiple number fields.
      */
     numList(fields) {
-        return this.#addFields(fields, numList);
+        return this.#addFieldsWith(fields, 'number', true);
     }
     /**
      * Add one or more string option fields.
      */
     opt(fields) {
-        return this.#addFields(fields, opt);
+        return this.#addFieldsWith(fields, 'string', false);
     }
     /**
      * Add one or more multiple string option fields.
      */
     optList(fields) {
-        return this.#addFields(fields, optList);
+        return this.#addFieldsWith(fields, 'string', true);
     }
     /**
      * Add one or more flag fields.
      */
     flag(fields) {
-        return this.#addFields(fields, flag);
+        return this.#addFieldsWith(fields, 'boolean', false);
     }
     /**
      * Add one or more multiple flag fields.
      */
     flagList(fields) {
-        return this.#addFields(fields, flagList);
+        return this.#addFieldsWith(fields, 'boolean', true);
     }
     /**
      * Generic field definition method. Similar to flag/flagList/number/etc,
@@ -641,29 +552,22 @@ class Jack {
      * fields on each one, or Jack won't know how to define them.
      */
     addFields(fields) {
-        const next = this;
-        for (const [name, field] of Object.entries(fields)) {
-            this.#validateName(name, field);
-            next.#fields.push({
-                type: 'config',
-                name,
-                value: field,
-            });
-        }
-        Object.assign(next.#configSet, fields);
-        return next;
+        return this.#addFields(this, fields);
     }
-    #addFields(fields, fn) {
-        const next = this;
+    #addFieldsWith(fields, type, multiple) {
+        return this.#addFields(this, fields, {
+            type,
+            multiple,
+        });
+    }
+    #addFields(next, fields, opt) {
         Object.assign(next.#configSet, Object.fromEntries(Object.entries(fields).map(([name, field]) => {
             this.#validateName(name, field);
-            const option = fn(field);
-            next.#fields.push({
-                type: 'config',
-                name,
-                value: option,
-            });
-            return [name, option];
+            const { type, multiple } = validateFieldMeta(field, opt);
+            const value = { ...field, type, multiple };
+            validateField(value, type, multiple);
+            next.#fields.push({ type: 'config', name, value });
+            return [name, value];
         })));
         return next;
     }
@@ -699,6 +603,7 @@ class Jack {
         if (this.#usage)
             return this.#usage;
         let headingLevel = 1;
+        //@ts-ignore
         const ui = (0, cliui_1.default)({ width });
         const first = this.#fields[0];
         let start = first?.type === 'heading' ? 1 : 0;
@@ -941,6 +846,11 @@ class Jack {
     }
 }
 exports.Jack = Jack;
+/**
+ * Main entry point. Create and return a {@link Jack} object.
+ */
+const jack = (options = {}) => new Jack(options);
+exports.jack = jack;
 // Unwrap and un-indent, so we can wrap description
 // strings however makes them look nice in the code.
 const normalize = (s, pre = false) => {
@@ -1002,9 +912,4 @@ const normalizeOneLine = (s, pre = false) => {
         .trim();
     return pre ? `\`${n}\`` : n;
 };
-/**
- * Main entry point. Create and return a {@link Jack} object.
- */
-const jack = (options = {}) => new Jack(options);
-exports.jack = jack;
 //# sourceMappingURL=index.js.map