burgee 0.0.0 → 0.3.0

package/dist/yargs-cliui.js

@@ -0,0 +1,421 @@
+const ANSI_PATTERN = '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))';
+export function stripAnsi(str) {
+    return typeof str === 'string' ? str.replace(new RegExp(ANSI_PATTERN, 'g'), '') : str;
+}
+const segmenter = new Intl.Segmenter();
+const EMOJI = new RegExp('^\\p{RGI_Emoji}$', 'v');
+function isWide(code) {
+    return ((code >= 0x1100 && code <= 0x115f) ||
+        code === 0x2329 ||
+        code === 0x232a ||
+        (code >= 0x2e80 && code <= 0x303e) ||
+        (code >= 0x3041 && code <= 0x33ff) ||
+        (code >= 0x3400 && code <= 0x4dbf) ||
+        (code >= 0x4e00 && code <= 0x9fff) ||
+        (code >= 0xa000 && code <= 0xa4cf) ||
+        (code >= 0xa960 && code <= 0xa97f) ||
+        (code >= 0xac00 && code <= 0xd7a3) ||
+        (code >= 0xf900 && code <= 0xfaff) ||
+        (code >= 0xfe10 && code <= 0xfe19) ||
+        (code >= 0xfe30 && code <= 0xfe6f) ||
+        (code >= 0xff00 && code <= 0xff60) ||
+        (code >= 0xffe0 && code <= 0xffe6) ||
+        (code >= 0x1f300 && code <= 0x1f64f) ||
+        (code >= 0x1f900 && code <= 0x1f9ff) ||
+        (code >= 0x20000 && code <= 0x3fffd));
+}
+export function stringWidth(input) {
+    if (typeof input !== 'string' || input.length === 0)
+        return 0;
+    const string = stripAnsi(input);
+    if (string.length === 0)
+        return 0;
+    let width = 0;
+    for (const { segment } of segmenter.segment(string)) {
+        const code = segment.codePointAt(0);
+        if (code <= 0x1f || (code >= 0x7f && code <= 0x9f))
+            continue;
+        if ((code >= 0x200b && code <= 0x200f) || code === 0xfeff)
+            continue;
+        if (code >= 0x300 && code <= 0x36f)
+            continue;
+        if (EMOJI.test(segment)) {
+            width += 2;
+            continue;
+        }
+        width += isWide(code) ? 2 : 1;
+    }
+    return width;
+}
+function closeCode(code) {
+    if (code === 1 || code === 2)
+        return 22;
+    if (code === 3)
+        return 23;
+    if (code === 4)
+        return 24;
+    if (code === 7)
+        return 27;
+    if (code === 8)
+        return 28;
+    if (code === 9)
+        return 29;
+    if ((code >= 30 && code <= 37) || (code >= 90 && code <= 97))
+        return 39;
+    if ((code >= 40 && code <= 47) || (code >= 100 && code <= 107))
+        return 49;
+    return undefined;
+}
+const ESC = '\u001B';
+const ESCAPES = new Set([ESC, '\u009B']);
+const END_CODE = 39;
+const ANSI_ESCAPE_BELL = '\u0007';
+const ANSI_CSI = '[';
+const ANSI_OSC = ']';
+const ANSI_SGR_TERMINATOR = 'm';
+const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+const wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = (uri) => `${ESC}${ANSI_ESCAPE_LINK}${uri}${ANSI_ESCAPE_BELL}`;
+const wordLengths = (string) => string.split(' ').map((character) => stringWidth(character));
+function wrapWord(rows, word, columns) {
+    const characters = [...word];
+    let isInsideEscape = false;
+    let isInsideLinkEscape = false;
+    let visible = stringWidth(stripAnsi(rows.at(-1)));
+    for (const [index, character] of characters.entries()) {
+        const characterLength = stringWidth(character);
+        if (visible + characterLength <= columns)
+            rows[rows.length - 1] += character;
+        else {
+            rows.push(character);
+            visible = 0;
+        }
+        if (ESCAPES.has(character)) {
+            isInsideEscape = true;
+            isInsideLinkEscape = characters.slice(index + 1).join('').startsWith(ANSI_ESCAPE_LINK);
+        }
+        if (isInsideEscape) {
+            if (isInsideLinkEscape) {
+                if (character === ANSI_ESCAPE_BELL) {
+                    isInsideEscape = false;
+                    isInsideLinkEscape = false;
+                }
+            }
+            else if (character === ANSI_SGR_TERMINATOR)
+                isInsideEscape = false;
+            continue;
+        }
+        visible += characterLength;
+        if (visible === columns && index < characters.length - 1) {
+            rows.push('');
+            visible = 0;
+        }
+    }
+    if (!visible && rows.at(-1).length > 0 && rows.length > 1)
+        rows[rows.length - 2] += rows.pop();
+}
+function stringVisibleTrimSpacesRight(string) {
+    const words = string.split(' ');
+    let last = words.length;
+    while (last > 0) {
+        if (stringWidth(words[last - 1]) > 0)
+            break;
+        last--;
+    }
+    if (last === words.length)
+        return string;
+    return words.slice(0, last).join(' ') + words.slice(last).join('');
+}
+function execWrap(string, columns, options = {}) {
+    if (options.trim !== false && string.trim() === '')
+        return '';
+    let returnValue = '';
+    let escapeCode;
+    let escapeUrl;
+    const lengths = wordLengths(string);
+    let rows = [''];
+    for (const [index, word] of string.split(' ').entries()) {
+        if (options.trim !== false)
+            rows[rows.length - 1] = rows.at(-1).trimStart();
+        let rowLength = stringWidth(rows.at(-1));
+        if (index !== 0) {
+            if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+                rows.push('');
+                rowLength = 0;
+            }
+            if (rowLength > 0 || options.trim === false) {
+                rows[rows.length - 1] += ' ';
+                rowLength++;
+            }
+        }
+        const length = lengths[index];
+        if (options.hard && length > columns) {
+            const remainingColumns = columns - rowLength;
+            const breaksStartingThisLine = 1 + Math.floor((length - remainingColumns - 1) / columns);
+            const breaksStartingNextLine = Math.floor((length - 1) / columns);
+            if (breaksStartingNextLine < breaksStartingThisLine)
+                rows.push('');
+            wrapWord(rows, word, columns);
+            continue;
+        }
+        if (rowLength + length > columns && rowLength > 0 && length > 0) {
+            if (options.wordWrap === false && rowLength < columns) {
+                wrapWord(rows, word, columns);
+                continue;
+            }
+            rows.push('');
+        }
+        if (rowLength + length > columns && options.wordWrap === false) {
+            wrapWord(rows, word, columns);
+            continue;
+        }
+        rows[rows.length - 1] += word;
+    }
+    if (options.trim !== false)
+        rows = rows.map(stringVisibleTrimSpacesRight);
+    const pre = [...rows.join('\n')];
+    for (const [index, character] of pre.entries()) {
+        returnValue += character;
+        if (ESCAPES.has(character)) {
+            const found = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`).exec(pre.slice(index).join(''));
+            const groups = found?.groups ?? {};
+            if (groups.code !== undefined) {
+                const code = Number.parseFloat(groups.code);
+                escapeCode = code === END_CODE ? undefined : code;
+            }
+            else if (groups.uri !== undefined)
+                escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+        }
+        const code = closeCode(Number(escapeCode));
+        if (pre[index + 1] === '\n') {
+            if (escapeUrl)
+                returnValue += wrapAnsiHyperlink('');
+            if (escapeCode && code)
+                returnValue += wrapAnsiCode(code);
+        }
+        else if (character === '\n') {
+            if (escapeCode && code)
+                returnValue += wrapAnsiCode(escapeCode);
+            if (escapeUrl)
+                returnValue += wrapAnsiHyperlink(escapeUrl);
+        }
+    }
+    return returnValue;
+}
+export function wrapAnsi(string, columns, options) {
+    return String(string)
+        .normalize()
+        .replace(/\r\n/g, '\n')
+        .split('\n')
+        .map((line) => execWrap(line, columns, options))
+        .join('\n');
+}
+const align = { right: alignRight, center: alignCenter };
+const top = 0;
+const right = 1;
+const bottom = 2;
+const left = 3;
+export class UI {
+    width;
+    wrap;
+    rows;
+    constructor(opts) {
+        this.width = opts.width;
+        this.wrap = opts.wrap ?? true;
+        this.rows = [];
+    }
+    span(...args) {
+        const cols = this.div(...args);
+        cols.span = true;
+    }
+    resetOutput() {
+        this.rows = [];
+    }
+    div(...args) {
+        if (args.length === 0)
+            this.div('');
+        if (this.wrap && this.shouldApplyLayoutDSL(...args) && typeof args[0] === 'string')
+            return this.applyLayoutDSL(args[0]);
+        const cols = args.map((arg) => (typeof arg === 'string' ? this.colFromString(arg) : arg));
+        this.rows.push(cols);
+        return cols;
+    }
+    shouldApplyLayoutDSL(...args) {
+        return args.length === 1 && typeof args[0] === 'string' && /[\t\n]/.test(args[0]);
+    }
+    applyLayoutDSL(str) {
+        const rows = str.split('\n').map((row) => row.split('\t'));
+        let leftColumnWidth = 0;
+        rows.forEach((columns) => {
+            if (columns.length > 1 && stringWidth(columns[0]) > leftColumnWidth) {
+                leftColumnWidth = Math.min(Math.floor(this.width * 0.5), stringWidth(columns[0]));
+            }
+        });
+        rows.forEach((columns) => {
+            this.div(...columns.map((r, i) => ({
+                text: r.trim(),
+                padding: this.measurePadding(r),
+                width: i === 0 && columns.length > 1 ? leftColumnWidth : undefined,
+            })));
+        });
+        return this.rows[this.rows.length - 1];
+    }
+    colFromString(text) {
+        return { text, padding: this.measurePadding(text) };
+    }
+    measurePadding(str) {
+        const noAnsi = stripAnsi(str);
+        return [0, /\s*$/.exec(noAnsi)[0].length, 0, /^\s*/.exec(noAnsi)[0].length];
+    }
+    toString() {
+        const lines = [];
+        this.rows.forEach((row) => {
+            this.rowToString(row, lines);
+        });
+        return lines
+            .filter((line) => !line.hidden)
+            .map((line) => line.text)
+            .join('\n');
+    }
+    rowToString(row, lines) {
+        this.rasterize(row).forEach((rrow, r) => {
+            let str = '';
+            rrow.forEach((col, c) => {
+                const column = row[c];
+                const { width } = column;
+                const wrapWidth = this.negatePadding(column);
+                let ts = col;
+                if (wrapWidth > stringWidth(col))
+                    ts += ' '.repeat(wrapWidth - stringWidth(col));
+                if (column.align && column.align !== 'left' && this.wrap) {
+                    const fn = align[column.align];
+                    ts = fn(ts, wrapWidth);
+                    if (stringWidth(ts) < wrapWidth)
+                        ts += ' '.repeat((width || 0) - stringWidth(ts) - 1);
+                }
+                const padding = column.padding || [0, 0, 0, 0];
+                if (padding[left])
+                    str += ' '.repeat(padding[left]);
+                str += addBorder(column, ts, '| ');
+                str += ts;
+                str += addBorder(column, ts, ' |');
+                if (padding[right])
+                    str += ' '.repeat(padding[right]);
+                if (r === 0 && lines.length > 0)
+                    str = this.renderInline(str, lines.at(-1));
+            });
+            lines.push({ text: str.replace(/ +$/, ''), span: row.span });
+        });
+        return lines;
+    }
+    renderInline(source, previousLine) {
+        const match = /^ */.exec(source);
+        const leadingWhitespace = match ? match[0].length : 0;
+        const target = previousLine.text;
+        const targetTextWidth = stringWidth(target.trimEnd());
+        if (!previousLine.span)
+            return source;
+        if (!this.wrap) {
+            previousLine.hidden = true;
+            return target + source;
+        }
+        if (leadingWhitespace < targetTextWidth)
+            return source;
+        previousLine.hidden = true;
+        return target.trimEnd() + ' '.repeat(leadingWhitespace - targetTextWidth) + source.trimStart();
+    }
+    rasterize(row) {
+        const rrows = [];
+        const widths = this.columnWidths(row);
+        let wrapped;
+        row.forEach((col, c) => {
+            col.width = widths[c];
+            if (this.wrap)
+                wrapped = wrapAnsi(col.text, this.negatePadding(col), { hard: true }).split('\n');
+            else
+                wrapped = col.text.split('\n');
+            if (col.border) {
+                wrapped.unshift(`.${'-'.repeat(this.negatePadding(col) + 2)}.`);
+                wrapped.push(`'${'-'.repeat(this.negatePadding(col) + 2)}'`);
+            }
+            if (col.padding) {
+                wrapped.unshift(...new Array(col.padding[top] || 0).fill(''));
+                wrapped.push(...new Array(col.padding[bottom] || 0).fill(''));
+            }
+            wrapped.forEach((str, r) => {
+                if (!rrows[r])
+                    rrows.push([]);
+                const rrow = rrows[r];
+                for (let i = 0; i < c; i++) {
+                    if (rrow[i] === undefined)
+                        rrow.push('');
+                }
+                rrow.push(str);
+            });
+        });
+        return rrows;
+    }
+    negatePadding(col) {
+        let wrapWidth = col.width || 0;
+        if (col.padding)
+            wrapWidth -= (col.padding[left] || 0) + (col.padding[right] || 0);
+        if (col.border)
+            wrapWidth -= 4;
+        return wrapWidth;
+    }
+    columnWidths(row) {
+        if (!this.wrap)
+            return row.map((col) => col.width || stringWidth(col.text));
+        let unset = row.length;
+        let remainingWidth = this.width;
+        const widths = row.map((col) => {
+            if (col.width) {
+                unset--;
+                remainingWidth -= col.width;
+                return col.width;
+            }
+            return undefined;
+        });
+        const unsetWidth = unset ? Math.floor(remainingWidth / unset) : 0;
+        return widths.map((w, i) => (w === undefined ? Math.max(unsetWidth, minWidth(row[i])) : w));
+    }
+}
+function addBorder(col, ts, style) {
+    if (col.border) {
+        if (/[.']-+[.']/.test(ts))
+            return '';
+        if (ts.trim().length !== 0)
+            return style;
+        return '  ';
+    }
+    return '';
+}
+function minWidth(col) {
+    const padding = col.padding || [];
+    const min = 1 + (padding[left] || 0) + (padding[right] || 0);
+    if (col.border)
+        return min + 4;
+    return min;
+}
+function getWindowWidth() {
+    if (typeof process === 'object' && process.stdout && process.stdout.columns)
+        return process.stdout.columns;
+    return 80;
+}
+function alignRight(str, width) {
+    str = str.trim();
+    const strWidth = stringWidth(str);
+    if (strWidth < width)
+        return ' '.repeat(width - strWidth) + str;
+    return str;
+}
+function alignCenter(str, width) {
+    str = str.trim();
+    const strWidth = stringWidth(str);
+    if (strWidth >= width)
+        return str;
+    return ' '.repeat((width - strWidth) >> 1) + str;
+}
+export function cliui(opts) {
+    return new UI({ width: opts?.width || getWindowWidth(), wrap: opts?.wrap });
+}

package/dist/yargs-command.d.ts

@@ -0,0 +1,82 @@
+/**
+ * yargs' command instance — `.command()` in its five shapes, `.commandDir()`, the
+ * builder/handler pipeline, positionals and the default command — ported for
+ * `burgee/yargs`.
+ */
+import { type Middleware } from './yargs-middleware.js';
+import type { PlatformShim } from './yargs-shim.js';
+import type { UsageInstance } from './yargs-usage.js';
+import { type Positional } from './yargs-utils.js';
+import type { ValidationInstance } from './yargs-validation.js';
+export interface CommandHandler {
+    original: string;
+    description?: string | false | undefined;
+    handler: (argv: any) => any;
+    builder: any;
+    middlewares: Middleware[];
+    deprecated?: boolean | string | undefined;
+    demanded: Positional[];
+    optional: Positional[];
+}
+export interface CommandHandlerDefinition {
+    command?: string | string[];
+    aliases?: string[];
+    describe?: string | false;
+    description?: string | false;
+    desc?: string | false;
+    builder?: any;
+    handler?: (argv: any) => any;
+    middlewares?: Middleware[];
+    deprecated?: boolean | string;
+}
+export interface CommandBuilderDefinition {
+    builder: any;
+    handler: (argv: any) => any;
+    middlewares?: Middleware[];
+    deprecated?: boolean | string;
+}
+export declare function isYargsInstance(y: any): boolean;
+export declare class CommandInstance {
+    private requireCache;
+    private handlers;
+    private aliasMap;
+    private defaultCommand;
+    private frozens;
+    private readonly shim;
+    private readonly usage;
+    private readonly globalMiddleware;
+    private readonly validation;
+    constructor(usage: UsageInstance, validation: ValidationInstance, globalMiddleware: any, shim: PlatformShim);
+    addDirectory(dir: string, req: (p: string) => any, callerFile: string, opts?: any): void;
+    addHandler(cmd: string | string[] | CommandHandlerDefinition, description?: string | false, builder?: any, handler?: (argv: any) => any, commandMiddleware?: Middleware[], deprecated?: boolean | string): void;
+    getCommandHandlers(): Record<string, CommandHandler>;
+    getCommands(): string[];
+    hasDefaultCommand(): boolean;
+    runCommand(command: string | null, yargs: any, parsed: any, commandIndex: number, helpOnly: boolean, helpOrVersionSet: boolean): any;
+    private applyBuilderUpdateUsageAndParse;
+    private parseAndUpdateUsage;
+    private shouldUpdateUsage;
+    private usageFromParentCommandsCommandHandler;
+    private handleValidationAndGetResult;
+    private applyMiddlewareAndGetResult;
+    private populatePositionals;
+    private populatePositional;
+    cmdToParseOptions(cmdString: string): {
+        array: string[];
+        default: Record<string, any>;
+        alias: Record<string, string[]>;
+        demand: Record<string, boolean>;
+    };
+    private postProcessPositionals;
+    private isDefaulted;
+    private isInConfigs;
+    runDefaultBuilderOn(yargs: any): any;
+    private extractDesc;
+    freeze(): void;
+    unfreeze(): void;
+    reset(): CommandInstance;
+}
+export declare function command(usage: UsageInstance, validation: ValidationInstance, globalMiddleware: any, shim: PlatformShim): CommandInstance;
+export declare function isCommandBuilderDefinition(builder: any): builder is CommandBuilderDefinition;
+export declare function isCommandBuilderCallback(builder: any): builder is (yargs: any, helpOrVersionSet: boolean) => any;
+export declare function isCommandHandlerDefinition(cmd: any): cmd is CommandHandlerDefinition;