burgee 0.0.0 → 0.2.0

package/dist/yargs-helpers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `burgee/yargs/helpers` — what `yargs/helpers` exports: `hideBin`, `applyExtends`
+ * and the parser.
+ */
+export { applyExtends, hideBin } from './yargs-utils.js';
+export { Parser } from './yargs-parser.js';

package/dist/yargs-helpers.js

@@ -0,0 +1,2 @@
+export { applyExtends, hideBin } from './yargs-utils.js';
+export { Parser } from './yargs-parser.js';

package/dist/yargs-middleware.d.ts

@@ -0,0 +1,32 @@
+/**
+ * yargs' middleware — global, per-command, and the coerce middleware `.coerce()`
+ * registers — ported for `burgee/yargs`.
+ */
+export interface MiddlewareCallback {
+    (argv: any, yargs: any): any;
+}
+export interface Middleware extends MiddlewareCallback {
+    applyBeforeValidation?: boolean;
+    global?: boolean;
+    mutates?: boolean;
+    applied?: boolean;
+    option?: string;
+}
+interface YargsLike {
+    getAliases: () => Record<string, string[]>;
+}
+export declare class GlobalMiddleware {
+    globalMiddleware: Middleware[];
+    frozens: Middleware[][];
+    yargs: YargsLike;
+    constructor(yargs: YargsLike);
+    addMiddleware(callback: Middleware | Middleware[], applyBeforeValidation: boolean, global?: boolean, mutates?: boolean): YargsLike;
+    addCoerceMiddleware(callback: Middleware, option: string): YargsLike;
+    getMiddleware(): Middleware[];
+    freeze(): void;
+    unfreeze(): void;
+    reset(): void;
+}
+export declare function commandMiddlewareFactory(commandMiddleware?: Middleware[]): Middleware[];
+export declare function applyMiddleware(argv: any, yargs: any, middlewares: Middleware[], beforeValidation: boolean): any;
+export {};

package/dist/yargs-middleware.js

@@ -0,0 +1,81 @@
+import { argsert, isPromise } from './yargs-utils.js';
+export class GlobalMiddleware {
+    globalMiddleware = [];
+    frozens = [];
+    yargs;
+    constructor(yargs) {
+        this.yargs = yargs;
+    }
+    addMiddleware(callback, applyBeforeValidation, global = true, mutates = false) {
+        argsert('<array|function> [boolean] [boolean] [boolean]', [callback, applyBeforeValidation, global], arguments.length);
+        if (Array.isArray(callback)) {
+            for (let i = 0; i < callback.length; i++) {
+                if (typeof callback[i] !== 'function')
+                    throw Error('middleware must be a function');
+                const m = callback[i];
+                m.applyBeforeValidation = applyBeforeValidation;
+                m.global = global;
+            }
+            Array.prototype.push.apply(this.globalMiddleware, callback);
+        }
+        else if (typeof callback === 'function') {
+            const m = callback;
+            m.applyBeforeValidation = applyBeforeValidation;
+            m.global = global;
+            m.mutates = mutates;
+            this.globalMiddleware.push(callback);
+        }
+        return this.yargs;
+    }
+    addCoerceMiddleware(callback, option) {
+        const aliases = this.yargs.getAliases();
+        this.globalMiddleware = this.globalMiddleware.filter((m) => {
+            const toCheck = [...(aliases[option] || []), option];
+            if (!m.option)
+                return true;
+            return !toCheck.includes(m.option);
+        });
+        callback.option = option;
+        return this.addMiddleware(callback, true, true, true);
+    }
+    getMiddleware() {
+        return this.globalMiddleware;
+    }
+    freeze() {
+        this.frozens.push([...this.globalMiddleware]);
+    }
+    unfreeze() {
+        const frozen = this.frozens.pop();
+        if (frozen !== undefined)
+            this.globalMiddleware = frozen;
+    }
+    reset() {
+        this.globalMiddleware = this.globalMiddleware.filter((m) => m.global);
+    }
+}
+export function commandMiddlewareFactory(commandMiddleware) {
+    if (!commandMiddleware)
+        return [];
+    return commandMiddleware.map((middleware) => {
+        middleware.applyBeforeValidation = false;
+        return middleware;
+    });
+}
+export function applyMiddleware(argv, yargs, middlewares, beforeValidation) {
+    return middlewares.reduce((acc, middleware) => {
+        if (middleware.applyBeforeValidation !== beforeValidation)
+            return acc;
+        if (middleware.mutates) {
+            if (middleware.applied)
+                return acc;
+            middleware.applied = true;
+        }
+        if (isPromise(acc)) {
+            return acc
+                .then((initialObj) => Promise.all([initialObj, middleware(initialObj, yargs)]))
+                .then(([initialObj, middlewareObj]) => Object.assign(initialObj, middlewareObj));
+        }
+        const result = middleware(acc, yargs);
+        return isPromise(result) ? result.then((middlewareObj) => Object.assign(acc, middlewareObj)) : Object.assign(acc, result);
+    }, argv);
+}

package/dist/yargs-parser.d.ts

@@ -0,0 +1,41 @@
+/**
+ * yargs-parser 22, ported for `burgee/yargs` (J9: burgee depends on nothing, so the
+ * parser yargs delegates to is ours too). Graded by yargs' own suite through
+ * compat-oracle; every branch, error string and configuration flag is the upstream's.
+ */
+export interface ParserMixin {
+    cwd: () => string;
+    format: (...args: any[]) => string;
+    normalize: (p: string) => string;
+    resolve: (...p: string[]) => string;
+    require: (p: string) => any;
+    env: () => Record<string, string | undefined>;
+}
+export interface DetailedArguments {
+    argv: Record<string, any>;
+    error: Error | null;
+    aliases: Record<string, string[]>;
+    newAliases: Record<string, boolean>;
+    defaulted: Record<string, boolean>;
+    configuration: Record<string, any>;
+}
+export declare function camelCase(str: string): string;
+export declare function decamelize(str: string, joinString?: string): string;
+export declare function looksLikeNumber(x: any): boolean;
+export declare function tokenizeArgString(argString: string | any[]): string[];
+export declare class YargsParser {
+    private readonly mixin;
+    constructor(mixin: ParserMixin);
+    parse(argsInput: string | any[], options?: any): DetailedArguments;
+}
+export interface Parser {
+    (args: string | any[], opts?: any): Record<string, any>;
+    detailed: (args: string | any[], opts?: any) => DetailedArguments;
+    camelCase: typeof camelCase;
+    decamelize: typeof decamelize;
+    looksLikeNumber: typeof looksLikeNumber;
+}
+declare const yargsParser: Parser;
+export { yargsParser as Parser };
+/** `burgee/yargs/parser`: what `import parser from 'yargs-parser'` gives, the same object the front-end parses with. */
+export default yargsParser;