jaywalk/dist/utils.js

Runtime type validation

"use strict";
var Promise = require('any-promise');
var IS_VALID_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
var _toString = Object.prototype.toString;
var _hasOwnProperty = Object.prototype.hasOwnProperty;
function ref($ref, $offset) {
    return { $ref: $ref, $offset: $offset };
}
exports.ref = ref;
function toValue(value) {
    if (value == null || typeof value !== 'object') {
        return function () { return value; };
    }
    if (Array.isArray(value.$ref)) {
        var ref_1 = value.$ref;
        var offset_1 = value.$offset;
        return function (path, context) {
            var fullPath = relativePath(path, ref_1, offset_1);
            var result = getValue(context.root, fullPath);
            if (result == null || typeof value !== 'object') {
                throw new TypeError("Value reference must be a primitive value (" + formatPath(fullPath) + ")");
            }
            return result;
        };
    }
    throw new TypeError('Value argument must be a reference or primitive value');
}
exports.toValue = toValue;
function getValue(value, path) {
    var result = value;
    for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {
        var key = path_1[_i];
        if (!_hasOwnProperty.call(result, key)) {
            return;
        }
        result = result[key];
    }
    return result;
}
exports.getValue = getValue;
function relativePath(ctx, ref, offset) {
    if (offset === void 0) { offset = 0; }
    var out = [];
    var rel = ctx.length - offset;
    if (rel < 0) {
        throw new TypeError("Unable to resolve offset \"" + offset + "\" from depth \"" + ctx.length + "\"");
    }
    for (var i = 0; i < rel; i++) {
        out.push(ctx[i]);
    }
    for (var i = 0; i < ref.length; i++) {
        out.push(ref[i]);
    }
    return out;
}
exports.relativePath = relativePath;
function identity(value) {
    return value;
}
exports.identity = identity;
function toNext(value, path, context, next) {
    return next(value);
}
exports.toNext = toNext;
function compose(tests) {
    return function (value, path, context, done) {
        var index = -1;
        function dispatch(pos, value) {
            if (pos <= index) {
                throw new TypeError('`next()` called multiple times');
            }
            index = pos;
            var fn = tests[pos] || done;
            return new Promise(function (resolve) {
                return resolve(fn(value, path, context, function next(value) {
                    return dispatch(pos + 1, value);
                }));
            });
        }
        return dispatch(0, value);
    };
}
exports.compose = compose;
function formatPath(segments) {
    var result = '';
    segments.forEach(function (segment, index) {
        if (IS_VALID_IDENTIFIER.test(segment)) {
            result += index === 0 ? segment : "." + segment;
        }
        else {
            result += "['" + segment.replace(/'/g, '\\\'') + "']";
        }
    });
    return result;
}
exports.formatPath = formatPath;
function wrapIsType(_this, value, path, context, _test, test) {
    var result = _test.call(_this, value, path, context);
    if (value == null) {
        return result;
    }
    return result + test.call(_this, value, path, context);
}
exports.wrapIsType = wrapIsType;
function isObject(obj) {
    return _toString.call(obj) === '[object Object]';
}
function extendSchema(schema, options) {
    var Constructor = schema.constructor;
    return new Constructor(schema._extend(options));
}
exports.extendSchema = extendSchema;
function merge() {
    var values = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        values[_i - 0] = arguments[_i];
    }
    var out;
    for (var _a = 0, values_1 = values; _a < values_1.length; _a++) {
        var value = values_1[_a];
        if (isObject(value)) {
            if (isObject(out)) {
                var res = {};
                for (var _b = 0, _c = Object.keys(out); _b < _c.length; _b++) {
                    var key = _c[_b];
                    res[key] = out[key];
                }
                for (var _d = 0, _e = Object.keys(value); _d < _e.length; _d++) {
                    var key = _e[_d];
                    res[key] = value[key];
                }
                out = res;
            }
            else {
                out = value;
            }
        }
        else {
            out = value;
        }
    }
    return out;
}
exports.merge = merge;
function isType(schema, value, path, context) {
    try {
        return schema._isType(value, path, context);
    }
    catch (err) {
        return 0;
    }
}
exports.isType = isType;
//# sourceMappingURL=utils.js.map