angular2-json-schema-form/dist/library/utilities/convert-json-schema.functions.js

Angular 2 JSON Schema Form builder

"use strict";
function convertJsonSchema3to4(schema) {
    var isArray = function (item) { return Array.isArray(item) ||
        Object.prototype.toString.call(item) === '[object Array]'; };
    var convertTypes = function (types, replace) {
        if (replace === void 0) { replace = false; }
        var newTypes = [];
        for (var _i = 0, _a = isArray(types) ? types : [types]; _i < _a.length; _i++) {
            var type = _a[_i];
            if (typeof type === 'object') {
                newTypes.push(type);
                replace = true;
            }
            else {
                newTypes.push({ 'type': type });
            }
        }
        return replace && newTypes;
    };
    if (typeof schema !== 'object') {
        return schema;
    }
    var newSchema = isArray(schema) ? [].concat(schema) : Object.assign({}, schema);
    var converted = false;
    if (newSchema.type) {
        if (typeof newSchema.type !== 'string') {
            converted = true;
            var anyOf = convertTypes(newSchema.type);
            if (anyOf) {
                newSchema.anyOf = anyOf;
                delete newSchema.type;
            }
        }
        else if (newSchema.type === 'any') {
            delete newSchema.type;
        }
    }
    if (newSchema.extends) {
        converted = true;
        newSchema.allOf = isArray(newSchema.extends) ?
            newSchema.extends : [newSchema.extends];
        delete newSchema.extends;
    }
    if (newSchema.disallow) {
        converted = true;
        newSchema.not = (typeof newSchema.disallow === 'string') ?
            { 'type': newSchema.disallow } :
            { 'anyOf': convertTypes(newSchema.disallow, true) };
        delete newSchema.disallow;
    }
    if (newSchema.properties) {
        var requiredArray = isArray(newSchema.required) ? newSchema.required : [];
        for (var _i = 0, _a = Object.keys(newSchema.properties); _i < _a.length; _i++) {
            var key = _a[_i];
            if (typeof newSchema.properties[key].required === 'boolean') {
                if (newSchema.properties[key].required) {
                    requiredArray.push(key);
                    converted = true;
                }
                delete newSchema.properties[key].required;
            }
        }
        if (requiredArray.length) {
            newSchema.required = requiredArray;
        }
    }
    if (newSchema.dependencies) {
        for (var _b = 0, _c = Object.keys(newSchema.dependencies); _b < _c.length; _b++) {
            var key = _c[_b];
            if (typeof newSchema.dependencies[key] === 'string') {
                converted = true;
                newSchema.dependencies[key] = [newSchema.dependencies[key]];
            }
        }
    }
    if (typeof newSchema.required === 'boolean') {
        converted = true;
        delete newSchema.required;
    }
    if (newSchema.divisibleBy) {
        converted = true;
        newSchema.multipleOf = newSchema.divisibleBy;
        delete newSchema.divisibleBy;
    }
    for (var _d = 0, _e = Object.keys(newSchema); _d < _e.length; _d++) {
        var key = _e[_d];
        if (['properties', 'patternProperties', 'dependencies'].indexOf(key) > -1) {
            for (var _f = 0, _g = Object.keys(newSchema[key]); _f < _g.length; _f++) {
                var subKey = _g[_f];
                newSchema[key][subKey] = convertJsonSchema3to4(newSchema[key][subKey]);
            }
        }
        else if (key !== 'enum') {
            if (isArray(newSchema[key])) {
                for (var _h = 0, _j = newSchema[key]; _h < _j.length; _h++) {
                    var subSchema = _j[_h];
                    subSchema = convertJsonSchema3to4(subSchema);
                }
            }
            else if (typeof newSchema[key] === 'object') {
                newSchema[key] = convertJsonSchema3to4(newSchema[key]);
            }
        }
    }
    if (converted === true) {
        if (newSchema.$schema) {
            if (newSchema.$schema === 'http://json-schema.org/draft-03/schema#') {
                newSchema.$schema = 'http://json-schema.org/draft-04/schema#';
            }
            else {
                delete newSchema.$schema;
            }
        }
        if (newSchema.id) {
            newSchema.id += '-CONVERTED-TO-DRAFT-04';
        }
    }
    return newSchema;
}
exports.convertJsonSchema3to4 = convertJsonSchema3to4;
//# sourceMappingURL=convert-json-schema.functions.js.map