@uides/stepwise 2.0.0-rc.33 → 2.0.2

package/generators/node_modules/jackspeak/dist/esm/index.js

@@ -0,0 +1,640 @@
+import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_node_util_1b29d436__ from "node:util";
+import * as __WEBPACK_EXTERNAL_MODULE__parse_args_js_f91a2c64__ from "./parse-args.js";
+import * as __WEBPACK_EXTERNAL_MODULE__isaacs_cliui_index_js_1d378291__ from "../../../@isaacs/cliui/index.js";
+const width = Math.min(process && process.stdout && process.stdout.columns || 80, 80);
+const indent = (n)=>(n - 1) * 2;
+const toEnvKey = (pref, key)=>[
+        pref,
+        key.replace(/[^a-zA-Z0-9]+/g, ' ')
+    ].join(' ').trim().toUpperCase().replace(/ /g, '_');
+const toEnvVal = (value, delim = '\n')=>{
+    const str = 'string' == typeof value ? value : 'boolean' == typeof value ? value ? '1' : '0' : 'number' == typeof value ? String(value) : Array.isArray(value) ? value.map((v)=>toEnvVal(v)).join(delim) : void 0;
+    if ('string' != typeof str) throw new Error(`could not serialize value to environment: ${JSON.stringify(value)}`);
+    return str;
+};
+const fromEnvVal = (env, type, multiple, delim = '\n')=>multiple ? env ? env.split(delim).map((v)=>fromEnvVal(v, type, false)) : [] : 'string' === type ? env : 'boolean' === type ? '1' === env : +env.trim();
+const isConfigType = (t)=>'string' == typeof t && ('string' === t || 'number' === t || 'boolean' === t);
+const undefOrType = (v, t)=>void 0 === v || typeof v === t;
+const valueType = (v)=>'string' == typeof v ? 'string' : 'boolean' == typeof v ? 'boolean' : 'number' == typeof v ? 'number' : Array.isArray(v) ? joinTypes([
+        ...new Set(v.map((v)=>valueType(v)))
+    ]) + '[]' : `${v.type}${v.multiple ? '[]' : ''}`;
+const joinTypes = (types)=>1 === types.length && 'string' == typeof types[0] ? 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 && 'object' == typeof o && isConfigType(o.type) && o.type === type && undefOrType(o.short, 'string') && undefOrType(o.description, 'string') && undefOrType(o.hint, 'string') && undefOrType(o.validate, 'function') && (void 0 === o.default || isValidValue(o.default, type, multi)) && !!o.multiple === multi;
+function num(o = {}) {
+    const { default: def, validate: val, ...rest } = o;
+    if (void 0 !== def && !isValidValue(def, 'number', false)) throw new TypeError('invalid default value');
+    const validate = val ? val : void 0;
+    return {
+        ...rest,
+        default: def,
+        validate,
+        type: 'number',
+        multiple: false
+    };
+}
+function numList(o = {}) {
+    const { default: def, validate: val, ...rest } = o;
+    if (void 0 !== def && !isValidValue(def, 'number', true)) throw new TypeError('invalid default value');
+    const validate = val ? val : void 0;
+    return {
+        ...rest,
+        default: def,
+        validate,
+        type: 'number',
+        multiple: true
+    };
+}
+function opt(o = {}) {
+    const { default: def, validate: val, ...rest } = o;
+    if (void 0 !== def && !isValidValue(def, 'string', false)) throw new TypeError('invalid default value');
+    const validate = val ? val : void 0;
+    return {
+        ...rest,
+        default: def,
+        validate,
+        type: 'string',
+        multiple: false
+    };
+}
+function optList(o = {}) {
+    const { default: def, validate: val, ...rest } = o;
+    if (void 0 !== def && !isValidValue(def, 'string', true)) throw new TypeError('invalid default value');
+    const validate = val ? val : void 0;
+    return {
+        ...rest,
+        default: def,
+        validate,
+        type: 'string',
+        multiple: true
+    };
+}
+function flag(o = {}) {
+    const { hint, default: def, validate: val, ...rest } = o;
+    if (void 0 !== def && !isValidValue(def, 'boolean', false)) throw new TypeError('invalid default value');
+    const validate = val ? val : void 0;
+    if (void 0 !== hint) throw new TypeError('cannot provide hint for flag');
+    return {
+        ...rest,
+        default: def,
+        validate,
+        type: 'boolean',
+        multiple: false
+    };
+}
+function flagList(o = {}) {
+    const { hint, default: def, validate: val, ...rest } = o;
+    if (void 0 !== def && !isValidValue(def, 'boolean', true)) throw new TypeError('invalid default value');
+    const validate = val ? val : void 0;
+    if (void 0 !== hint) throw new TypeError('cannot provide hint for flag list');
+    return {
+        ...rest,
+        default: def,
+        validate,
+        type: 'boolean',
+        multiple: true
+    };
+}
+const toParseArgsOptionsConfig = (options)=>{
+    const c = {};
+    for(const longOption in options){
+        const config = options[longOption];
+        if (!config) throw new Error('config must be an object: ' + longOption);
+        if (isConfigOption(config, 'number', true)) c[longOption] = {
+            type: 'string',
+            multiple: true,
+            default: config.default?.map((c)=>String(c))
+        };
+        else if (isConfigOption(config, 'number', false)) c[longOption] = {
+            type: 'string',
+            multiple: false,
+            default: void 0 === config.default ? void 0 : String(config.default)
+        };
+        else {
+            const conf = config;
+            c[longOption] = {
+                type: conf.type,
+                multiple: conf.multiple,
+                default: conf.default
+            };
+        }
+        const clo = c[longOption];
+        if ('string' == typeof config.short) clo.short = config.short;
+        if ('boolean' === config.type && !longOption.startsWith('no-') && !options[`no-${longOption}`]) c[`no-${longOption}`] = {
+            type: 'boolean',
+            multiple: config.multiple
+        };
+    }
+    return c;
+};
+const isHeading = (r)=>'heading' === r.type;
+const isDescription = (r)=>"description" === r.type;
+class Jack {
+    #configSet;
+    #shorts;
+    #options;
+    #fields = [];
+    #env;
+    #envPrefix;
+    #allowPositionals;
+    #usage;
+    #usageMarkdown;
+    constructor(options = {}){
+        this.#options = options;
+        this.#allowPositionals = false !== options.allowPositionals;
+        this.#env = void 0 === this.#options.env ? process.env : this.#options.env;
+        this.#envPrefix = options.envPrefix;
+        this.#configSet = Object.create(null);
+        this.#shorts = Object.create(null);
+    }
+    setConfigValues(values, source = '') {
+        try {
+            this.validate(values);
+        } catch (er) {
+            throw Object.assign(er, source ? {
+                source
+            } : {});
+        }
+        for (const [field, value] of Object.entries(values)){
+            const my = this.#configSet[field];
+            if (!my) throw new Error('unexpected field in config set: ' + field);
+            my.default = value;
+        }
+        return this;
+    }
+    parse(args = process.argv) {
+        if (args === process.argv) args = args.slice(void 0 !== process._eval ? 1 : 2);
+        if (this.#envPrefix) for (const [field, my] of Object.entries(this.#configSet)){
+            const ek = toEnvKey(this.#envPrefix, field);
+            const env = this.#env[ek];
+            if (void 0 !== env) my.default = fromEnvVal(env, my.type, !!my.multiple, my.delim);
+        }
+        const options = toParseArgsOptionsConfig(this.#configSet);
+        const result = (0, __WEBPACK_EXTERNAL_MODULE__parse_args_js_f91a2c64__.parseArgs)({
+            args,
+            options,
+            strict: false,
+            allowPositionals: this.#allowPositionals,
+            tokens: true
+        });
+        const p = {
+            values: {},
+            positionals: []
+        };
+        for (const token of result.tokens)if ('positional' === token.kind) {
+            p.positionals.push(token.value);
+            if (this.#options.stopAtPositional) {
+                p.positionals.push(...args.slice(token.index + 1));
+                return p;
+            }
+        } else if ('option' === token.kind) {
+            let value;
+            if (token.name.startsWith('no-')) {
+                const my = this.#configSet[token.name];
+                const pname = token.name.substring(3);
+                const pos = this.#configSet[pname];
+                if (pos && 'boolean' === pos.type && (!my || 'boolean' === my.type && !!my.multiple === !!pos.multiple)) {
+                    value = false;
+                    token.name = pname;
+                }
+            }
+            const my = this.#configSet[token.name];
+            if (!my) 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}'`);
+            if (void 0 === value) if (void 0 === token.value) {
+                if ('boolean' !== my.type) throw new Error(`No value provided for ${token.rawName}, expected ${my.type}`);
+                value = true;
+            } else {
+                if ('boolean' === my.type) throw new Error(`Flag ${token.rawName} does not take a value, received '${token.value}'`);
+                if ('string' === my.type) value = token.value;
+                else {
+                    value = +token.value;
+                    if (value !== value) throw new Error(`Invalid value '${token.value}' provided for '${token.rawName}' option, expected number`);
+                }
+            }
+            if (my.multiple) {
+                const pv = p.values;
+                const tn = pv[token.name] ?? [];
+                pv[token.name] = tn;
+                tn.push(value);
+            } else {
+                const pv = p.values;
+                pv[token.name] = value;
+            }
+        }
+        for (const [field, c] of Object.entries(this.#configSet))if (void 0 !== c.default && !(field in p.values)) p.values[field] = c.default;
+        for (const [field, value] of Object.entries(p.values)){
+            const valid = this.#configSet[field]?.validate;
+            if (valid && !valid(value)) throw new Error(`Invalid value provided for --${field}: ${JSON.stringify(value)}`);
+        }
+        this.#writeEnv(p);
+        return p;
+    }
+    #noNoFields(f, val, s = f) {
+        if (!f.startsWith('no-') || 'boolean' != typeof val) return;
+        const yes = f.substring(3);
+        this.#noNoFields(yes, val, s);
+        if (this.#configSet[yes]?.type === 'boolean') throw new Error(`do not set '${s}', instead set '${yes}' as desired.`);
+    }
+    validate(o) {
+        if (!o || 'object' != typeof o) throw new Error('Invalid config: not an object');
+        for(const field in o){
+            this.#noNoFields(field, o[field]);
+            const config = this.#configSet[field];
+            if (!config) throw new Error(`Unknown config option: ${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 (config.validate && !config.validate(o[field])) throw new Error(`Invalid config value for ${field}: ${o[field]}`);
+        }
+    }
+    #writeEnv(p) {
+        if (!this.#env || !this.#envPrefix) return;
+        for (const [field, value] of Object.entries(p.values)){
+            const my = this.#configSet[field];
+            this.#env[toEnvKey(this.#envPrefix, field)] = toEnvVal(value, my?.delim);
+        }
+    }
+    heading(text, level, { pre = false } = {}) {
+        if (void 0 === level) level = this.#fields.some((r)=>isHeading(r)) ? 2 : 1;
+        this.#fields.push({
+            type: 'heading',
+            text,
+            level,
+            pre
+        });
+        return this;
+    }
+    description(text, { pre } = {}) {
+        this.#fields.push({
+            type: "description",
+            text,
+            pre
+        });
+        return this;
+    }
+    num(fields) {
+        return this.#addFields(fields, num);
+    }
+    numList(fields) {
+        return this.#addFields(fields, numList);
+    }
+    opt(fields) {
+        return this.#addFields(fields, opt);
+    }
+    optList(fields) {
+        return this.#addFields(fields, optList);
+    }
+    flag(fields) {
+        return this.#addFields(fields, flag);
+    }
+    flagList(fields) {
+        return this.#addFields(fields, flagList);
+    }
+    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;
+    }
+    #addFields(fields, fn) {
+        const next = this;
+        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
+            ];
+        })));
+        return next;
+    }
+    #validateName(name, field) {
+        if (!/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(name)) throw new TypeError(`Invalid option name: ${name}, must be '-' delimited ASCII alphanumeric`);
+        if (this.#configSet[name]) throw new TypeError(`Cannot redefine option ${field}`);
+        if (this.#shorts[name]) throw new TypeError(`Cannot redefine option ${name}, already in use for ${this.#shorts[name]}`);
+        if (field.short) {
+            if (!/^[a-zA-Z0-9]$/.test(field.short)) throw new TypeError(`Invalid ${name} short option: ${field.short}, must be 1 ASCII alphanumeric character`);
+            if (this.#shorts[field.short]) throw new TypeError(`Invalid ${name} short option: ${field.short}, already in use for ${this.#shorts[field.short]}`);
+            this.#shorts[field.short] = name;
+            this.#shorts[name] = name;
+        }
+    }
+    usage() {
+        if (this.#usage) return this.#usage;
+        let headingLevel = 1;
+        const ui = (0, __WEBPACK_EXTERNAL_MODULE__isaacs_cliui_index_js_1d378291__["default"])({
+            width
+        });
+        const first = this.#fields[0];
+        let start = first?.type === 'heading' ? 1 : 0;
+        if (first?.type === 'heading') ui.div({
+            padding: [
+                0,
+                0,
+                0,
+                0
+            ],
+            text: normalize(first.text)
+        });
+        ui.div({
+            padding: [
+                0,
+                0,
+                0,
+                0
+            ],
+            text: 'Usage:'
+        });
+        if (this.#options.usage) ui.div({
+            text: this.#options.usage,
+            padding: [
+                0,
+                0,
+                0,
+                2
+            ]
+        });
+        else {
+            const cmd = (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.basename)(String(process.argv[1]));
+            const shortFlags = [];
+            const shorts = [];
+            const flags = [];
+            const opts = [];
+            for (const [field, config] of Object.entries(this.#configSet))if (config.short) if ('boolean' === config.type) shortFlags.push(config.short);
+            else shorts.push([
+                config.short,
+                config.hint || field
+            ]);
+            else if ('boolean' === config.type) flags.push(field);
+            else opts.push([
+                field,
+                config.hint || field
+            ]);
+            const sf = shortFlags.length ? ' -' + shortFlags.join('') : '';
+            const so = shorts.map(([k, v])=>` --${k}=<${v}>`).join('');
+            const lf = flags.map((k)=>` --${k}`).join('');
+            const lo = opts.map(([k, v])=>` --${k}=<${v}>`).join('');
+            const usage = `${cmd}${sf}${so}${lf}${lo}`.trim();
+            ui.div({
+                text: usage,
+                padding: [
+                    0,
+                    0,
+                    0,
+                    2
+                ]
+            });
+        }
+        ui.div({
+            padding: [
+                0,
+                0,
+                0,
+                0
+            ],
+            text: ''
+        });
+        const maybeDesc = this.#fields[start];
+        if (maybeDesc && isDescription(maybeDesc)) {
+            const print = normalize(maybeDesc.text, maybeDesc.pre);
+            start++;
+            ui.div({
+                padding: [
+                    0,
+                    0,
+                    0,
+                    0
+                ],
+                text: print
+            });
+            ui.div({
+                padding: [
+                    0,
+                    0,
+                    0,
+                    0
+                ],
+                text: ''
+            });
+        }
+        const { rows, maxWidth } = this.#usageRows(start);
+        for (const row of rows)if (row.left) {
+            const configIndent = indent(Math.max(headingLevel, 2));
+            if (row.left.length > maxWidth - 3) {
+                ui.div({
+                    text: row.left,
+                    padding: [
+                        0,
+                        0,
+                        0,
+                        configIndent
+                    ]
+                });
+                ui.div({
+                    text: row.text,
+                    padding: [
+                        0,
+                        0,
+                        0,
+                        maxWidth
+                    ]
+                });
+            } else ui.div({
+                text: row.left,
+                padding: [
+                    0,
+                    1,
+                    0,
+                    configIndent
+                ],
+                width: maxWidth
+            }, {
+                padding: [
+                    0,
+                    0,
+                    0,
+                    0
+                ],
+                text: row.text
+            });
+            if (row.skipLine) ui.div({
+                padding: [
+                    0,
+                    0,
+                    0,
+                    0
+                ],
+                text: ''
+            });
+        } else if (isHeading(row)) {
+            const { level } = row;
+            headingLevel = level;
+            const b = level <= 2 ? 1 : 0;
+            ui.div({
+                ...row,
+                padding: [
+                    0,
+                    0,
+                    b,
+                    indent(level)
+                ]
+            });
+        } else ui.div({
+            ...row,
+            padding: [
+                0,
+                0,
+                1,
+                indent(headingLevel + 1)
+            ]
+        });
+        return this.#usage = ui.toString();
+    }
+    usageMarkdown() {
+        if (this.#usageMarkdown) return this.#usageMarkdown;
+        const out = [];
+        let headingLevel = 1;
+        const first = this.#fields[0];
+        let start = first?.type === 'heading' ? 1 : 0;
+        if (first?.type === 'heading') out.push(`# ${normalizeOneLine(first.text)}`);
+        out.push('Usage:');
+        if (this.#options.usage) out.push(normalizeMarkdown(this.#options.usage, true));
+        else {
+            const cmd = (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.basename)(String(process.argv[1]));
+            const shortFlags = [];
+            const shorts = [];
+            const flags = [];
+            const opts = [];
+            for (const [field, config] of Object.entries(this.#configSet))if (config.short) if ('boolean' === config.type) shortFlags.push(config.short);
+            else shorts.push([
+                config.short,
+                config.hint || field
+            ]);
+            else if ('boolean' === config.type) flags.push(field);
+            else opts.push([
+                field,
+                config.hint || field
+            ]);
+            const sf = shortFlags.length ? ' -' + shortFlags.join('') : '';
+            const so = shorts.map(([k, v])=>` --${k}=<${v}>`).join('');
+            const lf = flags.map((k)=>` --${k}`).join('');
+            const lo = opts.map(([k, v])=>` --${k}=<${v}>`).join('');
+            const usage = `${cmd}${sf}${so}${lf}${lo}`.trim();
+            out.push(normalizeMarkdown(usage, true));
+        }
+        const maybeDesc = this.#fields[start];
+        if (maybeDesc && isDescription(maybeDesc)) {
+            out.push(normalizeMarkdown(maybeDesc.text, maybeDesc.pre));
+            start++;
+        }
+        const { rows } = this.#usageRows(start);
+        for (const row of rows)if (row.left) {
+            out.push('#'.repeat(headingLevel + 1) + ' ' + normalizeOneLine(row.left, true));
+            if (row.text) out.push(normalizeMarkdown(row.text));
+        } else if (isHeading(row)) {
+            const { level } = row;
+            headingLevel = level;
+            out.push(`${'#'.repeat(headingLevel)} ${normalizeOneLine(row.text, row.pre)}`);
+        } else out.push(normalizeMarkdown(row.text, !!row.pre));
+        return this.#usageMarkdown = out.join('\n\n') + '\n';
+    }
+    #usageRows(start) {
+        let maxMax = Math.max(12, Math.min(26, Math.floor(width / 3)));
+        let maxWidth = 8;
+        let prev;
+        const rows = [];
+        for (const field of this.#fields.slice(start)){
+            if ('config' !== field.type) {
+                if (prev?.type === 'config') prev.skipLine = true;
+                prev = void 0;
+                field.text = normalize(field.text, !!field.pre);
+                rows.push(field);
+                continue;
+            }
+            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 hint = value.hint || ('number' === value.type ? 'n' : 'string' === value.type ? field.name : void 0);
+            const short = value.short ? 'boolean' === value.type ? `-${value.short} ` : `-${value.short}<${hint}> ` : '';
+            const left = 'boolean' === value.type ? `${short}--${field.name}` : `${short}--${field.name}=<${hint}>`;
+            const row = {
+                text,
+                left,
+                type: 'config'
+            };
+            if (text.length > width - maxMax) row.skipLine = true;
+            if (prev && left.length > maxMax) prev.skipLine = true;
+            prev = row;
+            const len = left.length + 4;
+            if (len > maxWidth && len < maxMax) maxWidth = len;
+            rows.push(row);
+        }
+        return {
+            rows,
+            maxWidth
+        };
+    }
+    toJSON() {
+        return Object.fromEntries(Object.entries(this.#configSet).map(([field, def])=>[
+                field,
+                {
+                    type: def.type,
+                    ...def.multiple ? {
+                        multiple: true
+                    } : {},
+                    ...def.delim ? {
+                        delim: def.delim
+                    } : {},
+                    ...def.short ? {
+                        short: def.short
+                    } : {},
+                    ...def.description ? {
+                        description: normalize(def.description)
+                    } : {},
+                    ...def.validate ? {
+                        validate: def.validate
+                    } : {},
+                    ...void 0 !== def.default ? {
+                        default: def.default
+                    } : {}
+                }
+            ]));
+    }
+    [__WEBPACK_EXTERNAL_MODULE_node_util_1b29d436__.inspect.custom](_, options) {
+        return `Jack ${(0, __WEBPACK_EXTERNAL_MODULE_node_util_1b29d436__.inspect)(this.toJSON(), options)}`;
+    }
+}
+const normalize = (s, pre = false)=>pre ? s.split('\n').map((l)=>`\u200b${l}`).join('\n') : s.replace(/([^\n])\n[ \t]*([^\n])/g, (_, $1, $2)=>/^[-*]/.test($2) ? `${$1}\n${$2}` : `${$1} ${$2}`).replace(/([^\n])[ \t]+([^\n])/g, '$1 $2').replace(/\n{3,}/g, '\n\n').replace(/\n[ \t]+/g, '\n').trim();
+const normalizeMarkdown = (s, pre = false)=>{
+    const n = normalize(s, pre).replace(/\\/g, '\\\\');
+    return pre ? `\`\`\`\n${n.replace(/\u200b/g, '')}\n\`\`\`` : n.replace(/\n +/g, '\n').trim();
+};
+const normalizeOneLine = (s, pre = false)=>{
+    const n = normalize(s, pre).replace(/[\s\u200b]+/g, ' ').trim();
+    return pre ? `\`${n}\`` : n;
+};
+const jack = (options = {})=>new Jack(options);
+export { Jack, isConfigOption, isConfigType, jack };