@ndlib/ndlib-cdk2 1.0.21 → 1.0.23

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/jackspeak/dist/commonjs/index.js

@@ -21,51 +21,41 @@ const toEnvKey = (pref, key) => {
         .replace(/ /g, '_');
 };
 const toEnvVal = (value, delim = '\n') => {
-    const str = typeof value === 'string'
-        ? value
-        : typeof value === 'boolean'
-            ? value
-                ? '1'
+    const str = typeof value === 'string' ? value
+        : typeof value === 'boolean' ?
+            value ? '1'
                 : '0'
-            : typeof value === 'number'
-                ? String(value)
-                : Array.isArray(value)
-                    ? value
-                        .map((v) => toEnvVal(v))
-                        .join(delim)
-                    : /* c8 ignore start */
-                        undefined;
+            : typeof value === 'number' ? String(value)
+                : Array.isArray(value) ?
+                    value.map((v) => toEnvVal(v)).join(delim)
+                    : /* c8 ignore start */ undefined;
     if (typeof str !== 'string') {
         throw new Error(`could not serialize value to environment: ${JSON.stringify(value)}`);
     }
     /* c8 ignore stop */
     return str;
 };
-const fromEnvVal = (env, type, multiple, delim = '\n') => (multiple
-    ? env
-        ? env.split(delim).map(v => fromEnvVal(v, type, false))
+const fromEnvVal = (env, type, multiple, delim = '\n') => (multiple ?
+    env ? env.split(delim).map(v => fromEnvVal(v, type, false))
         : []
-    : type === 'string'
-        ? env
-        : type === 'boolean'
-            ? env === '1'
+    : 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)))]) + '[]'
+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)))]) + '[]'
                 : `${v.type}${v.multiple ? '[]' : ''}`;
-const joinTypes = (types) => types.length === 1 && typeof types[0] === 'string'
-    ? types[0]
+const joinTypes = (types) => types.length === 1 && typeof types[0] === 'string' ?
+    types[0]
     : `(${types.join('|')})`;
 const isValidValue = (v, type, multi) => {
     if (multi) {
@@ -85,80 +75,140 @@ const isConfigOption = (o, type, multi) => !!o &&
     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, ...rest } = o;
+    const { default: def, validate: val, validOptions, ...rest } = o;
     if (def !== undefined && !isValidValue(def, 'number', false)) {
-        throw new TypeError('invalid default value');
+        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
+    const validate = val ?
+        val
         : undefined;
     return {
         ...rest,
         default: def,
         validate,
+        validOptions,
         type: 'number',
         multiple: false,
     };
 }
 function numList(o = {}) {
-    const { default: def, validate: val, ...rest } = o;
+    const { default: def, validate: val, validOptions, ...rest } = o;
     if (def !== undefined && !isValidValue(def, 'number', true)) {
-        throw new TypeError('invalid default value');
+        throw new TypeError('invalid default value', {
+            cause: {
+                found: def,
+                wanted: 'number[]',
+            },
+        });
     }
-    const validate = val
-        ? val
+    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: true,
     };
 }
 function opt(o = {}) {
-    const { default: def, validate: val, ...rest } = o;
+    const { default: def, validate: val, validOptions, ...rest } = o;
     if (def !== undefined && !isValidValue(def, 'string', false)) {
-        throw new TypeError('invalid default value');
+        throw new TypeError('invalid default value', {
+            cause: {
+                found: def,
+                wanted: 'string',
+            },
+        });
     }
-    const validate = val
-        ? val
+    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,
     };
 }
 function optList(o = {}) {
-    const { default: def, validate: val, ...rest } = o;
+    const { default: def, validate: val, validOptions, ...rest } = o;
     if (def !== undefined && !isValidValue(def, 'string', true)) {
-        throw new TypeError('invalid default value');
+        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
+    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
+    const validate = val ?
+        val
         : undefined;
     if (hint !== undefined) {
         throw new TypeError('cannot provide hint for flag');
@@ -173,11 +223,12 @@ function flag(o = {}) {
 }
 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
+    const validate = val ?
+        val
         : undefined;
     if (hint !== undefined) {
         throw new TypeError('cannot provide hint for flag list');
@@ -210,8 +261,8 @@ const toParseArgsOptionsConfig = (options) => {
             c[longOption] = {
                 type: 'string',
                 multiple: false,
-                default: config.default === undefined
-                    ? undefined
+                default: config.default === undefined ?
+                    undefined
                     : String(config.default),
             };
         }
@@ -219,7 +270,7 @@ const toParseArgsOptionsConfig = (options) => {
             const conf = config;
             c[longOption] = {
                 type: conf.type,
-                multiple: conf.multiple,
+                multiple: !!conf.multiple,
                 default: conf.default,
             };
         }
@@ -277,14 +328,25 @@ class Jack {
             this.validate(values);
         }
         catch (er) {
-            throw Object.assign(er, source ? { source } : {});
+            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 };
+                }
+            }
+            throw e;
         }
         for (const [field, value] of Object.entries(values)) {
             const my = this.#configSet[field];
             // already validated, just for TS's benefit
             /* c8 ignore start */
             if (!my) {
-                throw new Error('unexpected field in config set: ' + field);
+                throw new Error('unexpected field in config set: ' + field, {
+                    cause: { found: field },
+                });
             }
             /* c8 ignore stop */
             my.default = value;
@@ -355,18 +417,27 @@ class Jack {
                     throw new Error(`Unknown option '${token.rawName}'. ` +
                         `To specify a positional argument starting with a '-', ` +
                         `place it at the end of the command after '--', as in ` +
-                        `'-- ${token.rawName}'`);
+                        `'-- ${token.rawName}'`, {
+                        cause: {
+                            found: token.rawName + (token.value ? `=${token.value}` : ''),
+                        },
+                    });
                 }
                 if (value === undefined) {
                     if (token.value === undefined) {
                         if (my.type !== 'boolean') {
-                            throw new Error(`No value provided for ${token.rawName}, expected ${my.type}`);
+                            throw new Error(`No value provided for ${token.rawName}, expected ${my.type}`, {
+                                cause: {
+                                    name: token.rawName,
+                                    wanted: valueType(my),
+                                },
+                            });
                         }
                         value = true;
                     }
                     else {
                         if (my.type === 'boolean') {
-                            throw new Error(`Flag ${token.rawName} does not take a value, received '${token.value}'`);
+                            throw new Error(`Flag ${token.rawName} does not take a value, received '${token.value}'`, { cause: { found: token } });
                         }
                         if (my.type === 'string') {
                             value = token.value;
@@ -375,7 +446,13 @@ class Jack {
                             value = +token.value;
                             if (value !== value) {
                                 throw new Error(`Invalid value '${token.value}' provided for ` +
-                                    `'${token.rawName}' option, expected number`);
+                                    `'${token.rawName}' option, expected number`, {
+                                    cause: {
+                                        name: token.rawName,
+                                        found: token.value,
+                                        wanted: 'number',
+                                    },
+                                });
                             }
                         }
                     }
@@ -400,8 +477,16 @@ 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)) {
-                throw new Error(`Invalid value provided for --${field}: ${JSON.stringify(value)}`);
+                cause ??= { name: field, found: value };
+            }
+            if (cause) {
+                throw new Error(`Invalid value provided for --${field}: ${JSON.stringify(value)}`, { cause });
             }
         }
         this.#writeEnv(p);
@@ -418,7 +503,7 @@ class Jack {
         // recurse so we get the core config key we care about.
         this.#noNoFields(yes, val, s);
         if (this.#configSet[yes]?.type === 'boolean') {
-            throw new Error(`do not set '${s}', instead set '${yes}' as desired.`);
+            throw new Error(`do not set '${s}', instead set '${yes}' as desired.`, { cause: { found: s, wanted: yes } });
         }
     }
     /**
@@ -427,22 +512,48 @@ class Jack {
      */
     validate(o) {
         if (!o || typeof o !== 'object') {
-            throw new Error('Invalid config: not an object');
+            throw new Error('Invalid config: not an object', {
+                cause: { found: o },
+            });
         }
+        const opts = o;
         for (const field in o) {
-            this.#noNoFields(field, o[field]);
+            const value = opts[field];
+            /* c8 ignore next - for TS */
+            if (value === undefined)
+                continue;
+            this.#noNoFields(field, value);
             const config = this.#configSet[field];
             if (!config) {
-                throw new Error(`Unknown config option: ${field}`);
+                throw new Error(`Unknown config option: ${field}`, {
+                    cause: { found: field },
+                });
             }
-            if (!isValidValue(o[field], config.type, !!config.multiple)) {
-                throw Object.assign(new Error(`Invalid value ${valueType(o[field])} for ${field}, expected ${valueType(config)}`), {
-                    field,
-                    value: o[field],
+            if (!isValidValue(value, config.type, !!config.multiple)) {
+                throw new Error(`Invalid value ${valueType(value)} for ${field}, expected ${valueType(config)}`, {
+                    cause: {
+                        name: field,
+                        found: value,
+                        wanted: valueType(config),
+                    },
                 });
             }
-            if (config.validate && !config.validate(o[field])) {
-                throw new Error(`Invalid config value for ${field}: ${o[field]}`);
+            let cause;
+            if (config.validOptions &&
+                !isValidOption(value, config.validOptions)) {
+                cause = {
+                    name: field,
+                    found: value,
+                    validOptions: config.validOptions,
+                };
+            }
+            if (config.validate && !config.validate(value)) {
+                cause ??= { name: field, found: value };
+            }
+            if (cause) {
+                throw new Error(`Invalid config value for ${field}: ${value}`, {
+                    cause,
+                });
             }
         }
     }
@@ -753,21 +864,21 @@ class Jack {
             const { value } = field;
             const desc = value.description || '';
             const mult = value.multiple ? 'Can be set multiple times' : '';
-            const dmDelim = mult && (desc.includes('\n') ? '\n\n' : '\n');
-            const text = normalize(desc + dmDelim + mult);
+            const opts = value.validOptions?.length ?
+                `Valid options:${value.validOptions.map(v => ` ${JSON.stringify(v)}`)}`
+                : '';
+            const dmDelim = desc.includes('\n') ? '\n\n' : '\n';
+            const extra = [opts, mult].join(dmDelim).trim();
+            const text = (normalize(desc) + dmDelim + extra).trim();
             const hint = value.hint ||
-                (value.type === 'number'
-                    ? 'n'
-                    : value.type === 'string'
-                        ? field.name
+                (value.type === 'number' ? 'n'
+                    : value.type === 'string' ? field.name
                         : undefined);
-            const short = !value.short
-                ? ''
-                : value.type === 'boolean'
-                    ? `-${value.short} `
+            const short = !value.short ? ''
+                : value.type === 'boolean' ? `-${value.short} `
                     : `-${value.short}<${hint}> `;
-            const left = value.type === 'boolean'
-                ? `${short}--${field.name}`
+            const left = value.type === 'boolean' ?
+                `${short}--${field.name}`
                 : `${short}--${field.name}=<${hint}>`;
             const row = { text, left, type: 'config' };
             if (text.length > width - maxMax) {
@@ -795,10 +906,11 @@ class Jack {
                 ...(def.multiple ? { multiple: true } : {}),
                 ...(def.delim ? { delim: def.delim } : {}),
                 ...(def.short ? { short: def.short } : {}),
-                ...(def.description
-                    ? { description: normalize(def.description) }
+                ...(def.description ?
+                    { description: normalize(def.description) }
                     : {}),
                 ...(def.validate ? { validate: def.validate } : {}),
+                ...(def.validOptions ? { validOptions: def.validOptions } : {}),
                 ...(def.default !== undefined ? { default: def.default } : {}),
             },
         ]));
@@ -813,12 +925,12 @@ class Jack {
 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) => pre
-    ? // prepend a ZWSP to each line so cliui doesn't strip it.
-        s
-            .split('\n')
-            .map(l => `\u200b${l}`)
-            .join('\n')
+const normalize = (s, pre = false) => pre ?
+    // prepend a ZWSP to each line so cliui doesn't strip it.
+    s
+        .split('\n')
+        .map(l => `\u200b${l}`)
+        .join('\n')
     : s
         // remove single line breaks, except for lists
         .replace(/([^\n])\n[ \t]*([^\n])/g, (_, $1, $2) => !/^[-*]/.test($2) ? `${$1} ${$2}` : `${$1}\n${$2}`)
@@ -832,8 +944,8 @@ const normalize = (s, pre = false) => pre
 // normalize for markdown printing, remove leading spaces on lines
 const normalizeMarkdown = (s, pre = false) => {
     const n = normalize(s, pre).replace(/\\/g, '\\\\');
-    return pre
-        ? `\`\`\`\n${n.replace(/\u200b/g, '')}\n\`\`\``
+    return pre ?
+        `\`\`\`\n${n.replace(/\u200b/g, '')}\n\`\`\``
         : n.replace(/\n +/g, '\n').trim();
 };
 const normalizeOneLine = (s, pre = false) => {