type2docfx/dist/idResolver.js

A tool to convert json format output from TypeDoc to universal reference model for DocFx to consume.

"use strict";
exports.__esModule = true;
var regex_1 = require("./common/regex");
function resolveIds(element, uidMapping, referenceMapping) {
    if (element.syntax) {
        if (element.syntax.parameters) {
            element.syntax.parameters.forEach(function (p) {
                p.type = restoreReferences(p.type, uidMapping, referenceMapping);
            });
        }
        if (element.syntax["return"]) {
            element.syntax["return"].type = restoreReferences(element.syntax["return"].type, uidMapping, referenceMapping);
        }
    }
    if (element["extends"]) {
        element["extends"].name = restoreReferences([element["extends"].name], uidMapping, referenceMapping)[0];
    }
    element.children.forEach(function (child) {
        resolveIds(child, uidMapping, referenceMapping);
    });
}
exports.resolveIds = resolveIds;
function restoreReferences(types, uidMapping, referenceMapping) {
    var restoredTypes = restoreTypes(types, uidMapping);
    return restoredTypes.map(function (restoreType) {
        if (restoreType) {
            var hasUid_1 = false;
            var restoreTypeTrim = restoreType.replace(regex_1.uidRegex, function (match, uid) {
                if (uid) {
                    hasUid_1 = true;
                    return uid;
                }
                return match;
            });
            if (hasUid_1 && referenceMapping[restoreTypeTrim] !== null) {
                referenceMapping[restoreTypeTrim] = restoreType;
            }
            return restoreTypeTrim;
        }
        return restoreType;
    });
}
function restoreTypes(types, uidMapping) {
    if (types) {
        return types.map(function (t) { return restoreType(t, uidMapping); });
    }
    return null;
}
function restoreType(type, uidMapping) {
    if (typeof (type) === 'string') {
        return type;
    }
    if (type.reflectedType) {
        type.reflectedType.key = restoreType(type.reflectedType.key, uidMapping);
        type.reflectedType.value = restoreType(type.reflectedType.value, uidMapping);
    }
    else if (type.genericType) {
        type.genericType.inner = type.genericType.inner.map(function (t) { return restoreType(t, uidMapping); });
        type.genericType.outter = restoreType(type.genericType.outter, uidMapping);
    }
    if (type.unionType) {
        type.unionType.types = type.unionType.types.map(function (t) { return restoreType(t, uidMapping); });
    }
    else if (type.intersectionType) {
        type.intersectionType.types = type.intersectionType.types.map(function (t) { return restoreType(t, uidMapping); });
    }
    else if (type.arrayType) {
        type.arrayType = restoreType(type.arrayType, uidMapping);
    }
    else {
        if (type.typeId && uidMapping[type.typeId]) {
            type.typeName = "@uid:" + uidMapping[type.typeId] + "!@";
        }
    }
    return typeToString(type);
}
function typeToString(type) {
    if (!type) {
        return 'function';
    }
    if (typeof (type) === 'string') {
        if (type[0] === '@') {
            return type;
        }
        else {
            var t = type.split('.');
            return t[t.length - 1];
        }
    }
    if (type.reflectedType) {
        return "[key: " + typeToString(type.reflectedType.key) + "]: " + typeToString(type.reflectedType.value);
    }
    else if (type.genericType) {
        return typeToString(type.genericType.outter) + "<" + (type.genericType.inner.map(function (t) { return typeToString(t); }).join(', ')) + ">";
    }
    else if (type.unionType) {
        return type.unionType.types.map(function (t) { return typeToString(t); }).join(' | ');
    }
    else if (type.intersectionType) {
        return type.intersectionType.types.map(function (t) { return typeToString(t); }).join(' & ');
    }
    else if (type.arrayType) {
        return typeToString(type.arrayType) + "[]";
    }
    else {
        return typeToString(type.typeName);
    }
}
exports.typeToString = typeToString;