dts-bundle-generator/helpers/typescript.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ts = require("typescript");
var node_modules_1 = require("./node-modules");
var namedDeclarationKinds = [
    ts.SyntaxKind.InterfaceDeclaration,
    ts.SyntaxKind.ClassDeclaration,
    ts.SyntaxKind.EnumDeclaration,
    ts.SyntaxKind.TypeAliasDeclaration,
    ts.SyntaxKind.ModuleDeclaration,
    ts.SyntaxKind.FunctionDeclaration,
    ts.SyntaxKind.VariableDeclaration,
];
function isNodeNamedDeclaration(node) {
    return namedDeclarationKinds.indexOf(node.kind) !== -1;
}
exports.isNodeNamedDeclaration = isNodeNamedDeclaration;
function hasNodeModifier(node, modifier) {
    return Boolean(node.modifiers && node.modifiers.some(function (nodeModifier) { return nodeModifier.kind === modifier; }));
}
exports.hasNodeModifier = hasNodeModifier;
function getActualSymbol(symbol, typeChecker) {
    if (symbol.flags & ts.SymbolFlags.Alias) {
        symbol = typeChecker.getAliasedSymbol(symbol);
    }
    return symbol;
}
exports.getActualSymbol = getActualSymbol;
/**
 * @see https://github.com/Microsoft/TypeScript/blob/f7c4fefeb62416c311077a699cc15beb211c25c9/src/compiler/utilities.ts#L626-L628
 */
function isGlobalScopeAugmentation(module) {
    return Boolean(module.flags & ts.NodeFlags.GlobalAugmentation);
}
/**
 * Returns whether node is ambient module declaration (declare module "name" or declare global)
 * @see https://github.com/Microsoft/TypeScript/blob/f7c4fefeb62416c311077a699cc15beb211c25c9/src/compiler/utilities.ts#L588-L590
 */
function isAmbientModule(node) {
    return ts.isModuleDeclaration(node) && (node.name.kind === ts.SyntaxKind.StringLiteral || isGlobalScopeAugmentation(node));
}
exports.isAmbientModule = isAmbientModule;
/**
 * Returns whether statement is `declare module` ModuleDeclaration (not `declare global` or `namespace`)
 */
function isDeclareModuleStatement(statement) {
    // `declare module ""`, `declare global` and `namespace {}` are ModuleDeclaration
    // but here we need to check only `declare module` statements
    return ts.isModuleDeclaration(statement) && !(statement.flags & ts.NodeFlags.Namespace) && !isGlobalScopeAugmentation(statement);
}
exports.isDeclareModuleStatement = isDeclareModuleStatement;
/**
 * Returns whether statement is `declare global` ModuleDeclaration
 */
function isDeclareGlobalStatement(statement) {
    return ts.isModuleDeclaration(statement) && isGlobalScopeAugmentation(statement);
}
exports.isDeclareGlobalStatement = isDeclareGlobalStatement;
/**
 * Returns whether node is `namespace` ModuleDeclaration
 */
function isNamespaceStatement(node) {
    return ts.isModuleDeclaration(node) && Boolean(node.flags & ts.NodeFlags.Namespace);
}
exports.isNamespaceStatement = isNamespaceStatement;
function getDeclarationsForSymbol(symbol) {
    var result = [];
    // Disabling tslint is for backward compat with TypeScript < 3
    // tslint:disable-next-line:strict-type-predicates
    if (symbol.valueDeclaration !== undefined) {
        result.push(symbol.valueDeclaration);
    }
    // Disabling tslint is for backward compat with TypeScript < 3
    // tslint:disable-next-line:strict-type-predicates
    if (symbol.declarations !== undefined) {
        result.push.apply(result, symbol.declarations);
    }
    return result;
}
exports.getDeclarationsForSymbol = getDeclarationsForSymbol;
function isDeclarationFromExternalModule(node) {
    return node_modules_1.getLibraryName(node.getSourceFile().fileName) !== null;
}
exports.isDeclarationFromExternalModule = isDeclarationFromExternalModule;
function getExportsForSourceFile(typeChecker, sourceFileSymbol) {
    if (sourceFileSymbol.exports !== undefined) {
        var commonJsExport = sourceFileSymbol.exports.get(ts.InternalSymbolName.ExportEquals);
        if (commonJsExport !== undefined) {
            return [
                {
                    symbol: getActualSymbol(commonJsExport, typeChecker),
                    type: 0 /* CommonJS */,
                },
            ];
        }
    }
    var result = typeChecker
        .getExportsOfModule(sourceFileSymbol)
        .map(function (symbol) { return ({ symbol: symbol, type: 1 /* ES6Named */ }); });
    if (sourceFileSymbol.exports !== undefined) {
        var defaultExportSymbol_1 = sourceFileSymbol.exports.get(ts.InternalSymbolName.Default);
        if (defaultExportSymbol_1 !== undefined) {
            var defaultExport = result.find(function (exp) { return exp.symbol === defaultExportSymbol_1; });
            if (defaultExport !== undefined) {
                defaultExport.type = 2 /* ES6Default */;
            }
            else {
                // it seems that default export is always returned by getExportsOfModule
                // but let's add it to be sure add if there is no such export
                result.push({
                    symbol: defaultExportSymbol_1,
                    type: 2 /* ES6Default */,
                });
            }
        }
    }
    result.forEach(function (symbol) {
        symbol.symbol = getActualSymbol(symbol.symbol, typeChecker);
    });
    return result;
}
exports.getExportsForSourceFile = getExportsForSourceFile;
function getExportTypeForDeclaration(exportedSymbols, typeChecker, declaration) {
    if (ts.isVariableStatement(declaration)) {
        if (declaration.declarationList.declarations.length === 0) {
            return null;
        }
        var firstDeclarationExportType_1 = getExportTypeForName(exportedSymbols, typeChecker, declaration.declarationList.declarations[0].name);
        var allDeclarationsHaveSameExportType = declaration.declarationList.declarations.every(function (variableDecl) {
            // all declaration should have the same export type
            // TODO: for now it's not supported to have different type of exports
            return getExportTypeForName(exportedSymbols, typeChecker, variableDecl.name) === firstDeclarationExportType_1;
        });
        if (!allDeclarationsHaveSameExportType) {
            // log warn?
            return null;
        }
        return firstDeclarationExportType_1;
    }
    return getExportTypeForName(exportedSymbols, typeChecker, declaration.name);
}
exports.getExportTypeForDeclaration = getExportTypeForDeclaration;
function getExportTypeForName(exportedSymbols, typeChecker, name) {
    if (name === undefined) {
        return null;
    }
    if (ts.isArrayBindingPattern(name) || ts.isObjectBindingPattern(name)) {
        // TODO: binding patterns in variable declarations are not supported for now
        // see https://github.com/microsoft/TypeScript/issues/30598 also
        return null;
    }
    var declarationSymbol = typeChecker.getSymbolAtLocation(name);
    var exportedSymbol = exportedSymbols.find(function (rootExport) { return rootExport.symbol === declarationSymbol; });
    if (exportedSymbol === undefined) {
        return null;
    }
    return exportedSymbol.type;
}