decline-ts/lib/Accumulator/index.js

Composable command-line parser for TypeScript - a (partial) porting of Scala decline using fp-ts

"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;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Accumulator = exports.AccumulatorMatch = exports.AccumulatorArgOut = void 0;
const fp_ts_1 = require("fp-ts");
const function_1 = require("fp-ts/function");
const Parser_1 = require("../Parser");
const Result_1 = require("../Result");
const ArgOut_1 = require("./ArgOut");
const Match_1 = require("./Match");
const Ap = __importStar(require("./types/Ap"));
const Argument = __importStar(require("./types/Argument"));
const Arguments = __importStar(require("./types/Arguments"));
const Flag = __importStar(require("./types/Flag"));
const OrElse = __importStar(require("./types/OrElse"));
const Pure = __importStar(require("./types/Pure"));
const Regular = __importStar(require("./types/Regular"));
const Subcommand = __importStar(require("./types/Subcommand"));
const Validate = __importStar(require("./types/Validate"));
exports.AccumulatorArgOut = ArgOut_1.ArgOut;
exports.AccumulatorMatch = Match_1.Match;
var Accumulator;
(function (Accumulator) {
    /**
     * Constructors
     */
    Accumulator.orElse = OrElse.of;
    Accumulator.fromOpts = (opts) => {
        switch (opts._tag) {
            case 'Pure':
                return Pure.of(Result_1.Result.success(opts.a));
            case 'App':
                return Ap.of(Accumulator.fromOpts(opts.f), Accumulator.fromOpts(opts.a));
            case 'OrElse':
                return OrElse.of(Accumulator.fromOpts(opts.a), Accumulator.fromOpts(opts.b));
            case 'Single':
                return fromSingle(opts.opt);
            case 'Repeated':
                return fromRepeated(opts.opt);
            case 'Subcommand':
                return Subcommand.of(opts.command.name, Parser_1.Parser(opts.command));
            case 'Validate':
                return function_1.pipe(Accumulator.fromOpts(opts.value), Accumulator.mapValidated(opts.validate));
            case 'HelpFlag':
                return function_1.pipe(Accumulator.fromOpts(opts.flag), Accumulator.mapValidated(() => fp_ts_1.either.left(fp_ts_1.readonlyArray.empty)));
        }
    };
    const fromSingle = (opt) => {
        switch (opt._tag) {
            case 'Regular':
                return function_1.pipe(Regular.of(opt.names), // TODO: cast bad.
                Accumulator.map(fp_ts_1.readonlyNonEmptyArray.last));
            case 'Flag':
                return function_1.pipe(Flag.of(opt.names), // TODO: cast bad.
                Accumulator.map(fp_ts_1.readonlyNonEmptyArray.last));
            case 'Argument':
                return Argument.of;
        }
    };
    const fromRepeated = (opt) => {
        switch (opt._tag) {
            case 'Regular':
                return Regular.of(opt.names);
            case 'Flag':
                return Flag.of(opt.names);
            case 'Argument':
                return Arguments.of([]);
        }
    };
    Accumulator.instances = {
        [Pure.URI]: Pure.pure,
        [Ap.URI]: Ap.ap,
        [OrElse.URI]: OrElse.orElse,
        [Regular.URI]: Regular.regular,
        [Flag.URI]: Flag.flag,
        [Argument.URI]: Argument.argument,
        [Arguments.URI]: Arguments.arguments_,
        [Subcommand.URI]: Subcommand.subcommand,
        [Validate.URI]: Validate.validate,
    };
    /**
     * Methods
     */
    Accumulator.parseOption = (name) => (fa) => function_1.pipe(fa, withMethod(fa._tag, 'parseOption')(name));
    Accumulator.parseArg = (arg) => (fa) => {
        const method = withMethod(fa._tag, 'parseArg');
        return method === undefined
            ? fp_ts_1.readonlyNonEmptyArray.of(fp_ts_1.either.left(fa))
            : function_1.pipe(fa, method(arg));
    };
    Accumulator.parseSub = (command) => (fa) => function_1.pipe(fa, withMethod(fa._tag, 'parseSub')(command));
    Accumulator.result = (fa) => function_1.pipe(fa, withMethod(fa._tag, 'result'));
    Accumulator.mapValidated = (f) => (fa) => Validate.of(fa, f);
    Accumulator.map = (f) => Accumulator.mapValidated(function_1.flow(f, fp_ts_1.either.right));
})(Accumulator = exports.Accumulator || (exports.Accumulator = {}));
const withMethod = (uri, method) => Accumulator.instances[uri][method];