json-processing/dist/argv.js

JSON Processing Tool

'use strict';
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.usage = void 0;
//import pap from 'posix-argv-parser';
const command_line_args_1 = __importDefault(require("command-line-args"));
const command_line_usage_1 = __importDefault(require("command-line-usage"));
const fs_1 = require("fs");
const outputs = __importStar(require("./lib/output"));
const lodash_1 = __importDefault(require("lodash"));
const path_1 = require("path");
const outputSelector = outputs;
const optionDefinitions = [
    { name: 'input', alias: 'i', type: (file) => fs_1.createReadStream(file), defaultValue: process.stdin,
        description: 'Input file path (defaults to stdin)',
        typeLabel: '[underline]{file}' },
    { name: 'output', alias: 'o', type: (file) => fs_1.createWriteStream(file), defaultValue: process.stdout,
        description: 'Output file path (defaults to stdout)',
        typeLabel: '[underline]{file}' },
    { name: 'output-mode', alias: 'm', type: (mode) => outputSelector[dashToCamelCase(mode)], defaultValue: outputSelector.tableAscii,
        description: 'Output mode. "raw", "json" or "table-ascii" (defaults to "table-ascii")',
        typeLabel: '[underline]{mode}' },
    { name: 'home', alias: 'h', type: String, defaultValue: path_1.resolve(require('os').homedir(), '.jp'),
        description: 'Script home path (defaults to ~/.jp)',
        typeLabel: '[underline]{directory}' },
    { name: 'inline', alias: 'l', type: String,
        description: 'Inline script definition',
        typeLabel: '[underline]{script}' },
    { name: 'command', type: String, multiple: true, defaultOption: true,
        description: 'Repository command to invoke',
        typeLabel: '[underline]{command}' },
    { name: 'help', type: Boolean, defaultValue: false,
        description: 'Prints this help message' }
];
exports.default = (argv) => new Promise((resolve, reject) => {
    let options;
    try {
        options = command_line_args_1.default(optionDefinitions, argv && {
            argv: argv
        });
        if (options.help)
            throw new Error();
        if (!lodash_1.default.isEmpty(options.command))
            options.command = {
                name: options.command[0],
                args: options.command.slice(1).map((p) => {
                    p = /^([^:]+):(.+)$/.exec(p);
                    return { [p[1]]: p[2] };
                }).reduce((args, arg) => lodash_1.default.merge({}, args, arg), {})
            };
    }
    catch (e) {
        const error = new Error('ARGV_ERROR');
        reject(error);
        return;
    }
    resolve(options);
});
function usage() {
    const version = require('../package.json').version;
    return `\njp v${version}\n${command_line_usage_1.default([
        {
            header: 'Usage',
            content: 'jp [options] [<command> [<arg:value>...]]'
        },
        {
            header: 'Options',
            optionList: optionDefinitions.
                filter(opt => opt.name !== 'command')
        },
        {
            header: 'Synopsis',
            content: [
                '$ cat some.json | jp -l \'select(".number") |> map(i => i + 1)\' -m json',
                '$ jp some/command',
                '$ jp some/command -l \'|> filter(v => v === "SOME_VALUE")\''
            ]
        }
    ])}`;
}
exports.usage = usage;
function dashToCamelCase(string) {
    return string.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
}