@whisklabs/grpc/dist/esm/parser/tokens/options.js

gRPC generator and http library for typescript

import { isPresent } from '@whisklabs/typeguards';
import { next, setComment, writeComment } from '../comment';
import { Thrower } from '../thrower';
import { ch, check, cut, cutStr, insertOption, semicolon } from '../utils';
import { isNumber, isStr, isText } from '../validators';
var parse = function (value) {
    return value === 'true' ? true : value === 'false' ? false : isNumber(value) ? value : isStr(value) ? cutStr(value) : value;
};
export function OptionValue(tokens) {
    var value = tokens.shift();
    if (value !== '{') {
        return parse(value);
    }
    var result = {};
    var field;
    while (tokens.length > 0) {
        switch (next(tokens)) {
            case '}':
                cut(tokens, 1);
                return result;
            case ':':
                cut(tokens, 1);
                insertOption(result, field, tokens[0] === '[' ? OptionArray(tokens) : OptionValue(tokens));
                break;
            case '{':
                insertOption(result, field, OptionValue(tokens));
                break;
            case undefined:
                continue;
            default:
                field = tokens.shift();
        }
    }
    throw new Thrower('option array', [['no close tag "}"', 0]]);
}
export function OptionArray(tokens) {
    var options = [];
    while (tokens.length > 0) {
        switch (next(tokens)) {
            case '[':
            case ',':
                cut(tokens, 1);
                options.push(OptionValue(tokens));
                break;
            case ']':
                cut(tokens, 1);
                return options;
            case undefined:
                continue;
            default:
                throw new Thrower('options array', [["Unexpected token \"".concat(tokens[0], "\""), 0]]);
        }
    }
    throw new Thrower('options array', [['no close tag "]"', 0]]);
}
export function ParseOption(tokens) {
    var _a = check({
        type: 'option',
        tokens: tokens,
        rules: [
            ch('(', { ignore: true }),
            ch(isText, { result: true }),
            ch(')', { ignore: true }),
            ch(isText, { result: true, ignore: true }),
            ch('='),
            ch([isText, '{']),
        ],
    }), len = _a.len, results = _a.results;
    cut(tokens, len - 1);
    var field = results[0] + results[1];
    var value = OptionValue(tokens);
    return { field: field, value: value };
}
export function InnerOptions(tokens) {
    var options = {};
    setComment(options);
    while (tokens.length > 0) {
        switch (next(tokens)) {
            case '[':
            case ',': {
                cut(tokens, 1);
                var _a = ParseOption(tokens), field = _a.field, value = _a.value;
                var path = field.split('.');
                var lastFieldName = path.pop();
                var opt = options;
                for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {
                    var p = path_1[_i];
                    if (!isPresent(opt[p])) {
                        opt[p] = {};
                    }
                    opt = opt[p];
                }
                insertOption(opt, lastFieldName, value);
                break;
            }
            case ']':
                cut(tokens, 1);
                writeComment(options);
                return options;
            case undefined:
                continue;
            default:
                throw new Thrower('inner options', [["Unexpected token \"".concat(tokens[0], "\""), 0]]);
        }
    }
    throw new Thrower('inner options', [['no close tag "]"', 0]]);
}
export function ParseOptions(tokens) {
    var len = check({ tokens: tokens, rules: [ch('option')], type: 'option' }).len;
    cut(tokens, len);
    var result = ParseOption(tokens);
    semicolon(tokens);
    return result;
}
//# sourceMappingURL=options.js.map