dts-bundle-generator/bundle-generator.js

"use strict";
var __assign = (this && this.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
Object.defineProperty(exports, "__esModule", { value: true });
var ts = require("typescript");
var path = require("path");
var compile_dts_1 = require("./compile-dts");
var types_usage_evaluator_1 = require("./types-usage-evaluator");
var typescript_helpers_1 = require("./typescript-helpers");
var node_modules_helpers_1 = require("./node-modules-helpers");
var module_info_1 = require("./module-info");
var generate_output_1 = require("./generate-output");
var logger_1 = require("./logger");
var skippedNodes = [
    ts.SyntaxKind.ExportDeclaration,
    ts.SyntaxKind.ImportDeclaration,
    ts.SyntaxKind.ImportEqualsDeclaration,
];
function generateDtsBundle(filePath, options) {
    if (options === void 0) { options = {}; }
    if (!ts.sys.fileExists(filePath)) {
        throw new Error("File \"" + filePath + "\" does not exist");
    }
    var program = compile_dts_1.compileDts(filePath, options.preferredConfigPath);
    var typeChecker = program.getTypeChecker();
    var criteria = {
        allowedTypesLibraries: options.allowedTypesLibraries,
        importedLibraries: options.importedLibraries,
        inlinedLibraries: options.inlinedLibraries || [],
        typeRoots: ts.getEffectiveTypeRoots(program.getCompilerOptions(), {}),
    };
    var sourceFiles = program.getSourceFiles().filter(function (file) {
        return module_info_1.getModuleInfo(file.fileName, criteria).type !== 0 /* ShouldNotBeUsed */;
    });
    logger_1.verboseLog("Input source files:\n  " + sourceFiles.map(function (file) { return file.fileName; }).join('\n  '));
    var typesUsageEvaluator = new types_usage_evaluator_1.TypesUsageEvaluator(sourceFiles, typeChecker);
    var rootSourceFile = getRootSourceFile(program);
    var rootSourceFileSymbol = typeChecker.getSymbolAtLocation(rootSourceFile);
    if (rootSourceFileSymbol === undefined) {
        throw new Error('Symbol for root source file not found');
    }
    var rootFileExports = typeChecker.getExportsOfModule(rootSourceFileSymbol).map(function (symbol) { return typescript_helpers_1.getActualSymbol(symbol, typeChecker); });
    var collectionResult = {
        typesReferences: new Set(),
        imports: new Map(),
        statements: [],
    };
    var updateResultCommonParams = {
        isStatementUsed: function (statement) { return isNodeUsed(statement, rootFileExports, typesUsageEvaluator, typeChecker); },
        shouldStatementBeImported: function (statement) { return shouldNodeBeImported(statement, rootFileExports, typesUsageEvaluator); },
        shouldDeclareGlobalBeInlined: function (currentModule) { return Boolean(options.inlineDeclareGlobals) && currentModule.type === 1 /* ShouldBeInlined */; },
        getModuleInfo: function (fileName) { return module_info_1.getModuleInfo(fileName, criteria); },
        getDeclarationsForExportedAssignment: function (exportAssignment) {
            var symbolForExpression = typeChecker.getSymbolAtLocation(exportAssignment.expression);
            if (symbolForExpression === undefined) {
                return [];
            }
            var symbol = typescript_helpers_1.getActualSymbol(symbolForExpression, typeChecker);
            return getDeclarationsForSymbol(symbol);
        },
    };
    for (var _i = 0, sourceFiles_1 = sourceFiles; _i < sourceFiles_1.length; _i++) {
        var sourceFile = sourceFiles_1[_i];
        logger_1.verboseLog("\n\n======= Preparing file: " + sourceFile.fileName + " =======");
        var prevStatementsCount = collectionResult.statements.length;
        updateResult(__assign({}, updateResultCommonParams, { currentModule: module_info_1.getModuleInfo(sourceFile.fileName, criteria), statements: sourceFile.statements }), collectionResult);
        if (collectionResult.statements.length === prevStatementsCount) {
            logger_1.verboseLog("No output for file: " + sourceFile.fileName);
        }
    }
    if (options.failOnClass) {
        var isClassStatementFound = collectionResult.statements.some(function (statement) { return ts.isClassDeclaration(statement); });
        if (isClassStatementFound) {
            throw new Error('At least 1 class statement is found in generated dts.');
        }
    }
    for (var _a = 0, _b = rootSourceFile.statements; _a < _b.length; _a++) {
        var statement = _b[_a];
        // add skipped by `updateResult` `export default` from root file if present
        if (ts.isExportAssignment(statement) && !statement.isExportEquals) {
            collectionResult.statements.push(statement);
        }
    }
    return generate_output_1.generateOutput(__assign({}, collectionResult, { needStripDefaultKeywordForStatement: function (statement) { return statement.getSourceFile() !== rootSourceFile; }, shouldStatementHasExportKeyword: function (statement) {
            var result = true;
            if (ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement) || ts.isFunctionDeclaration(statement)) {
                // not every class, enum and function can be exported (only exported from root file can)
                result = isDeclarationExported(rootFileExports, typeChecker, statement);
                if (ts.isEnumDeclaration(statement)) {
                    // const enum always can be exported
                    result = result || typescript_helpers_1.hasNodeModifier(statement, ts.SyntaxKind.ConstKeyword);
                }
            }
            else if (typescript_helpers_1.isDeclareGlobalStatement(statement)) {
                result = false;
            }
            return result;
        } }), {
        sortStatements: options.sortNodes,
        umdModuleName: options.umdModuleName,
    });
}
exports.generateDtsBundle = generateDtsBundle;
// tslint:disable-next-line:cyclomatic-complexity
function updateResult(params, result) {
    if (params.currentModule.type === 0 /* ShouldNotBeUsed */) {
        return;
    }
    for (var _i = 0, _a = params.statements; _i < _a.length; _i++) {
        var statement = _a[_i];
        // we should skip import and exports statements
        if (skippedNodes.indexOf(statement.kind) !== -1) {
            continue;
        }
        if (typescript_helpers_1.isDeclareModuleStatement(statement)) {
            updateResultForModuleDeclaration(statement, params, result);
            continue;
        }
        if (params.currentModule.type === 4 /* ShouldBeUsedForModulesOnly */) {
            continue;
        }
        if (typescript_helpers_1.isDeclareGlobalStatement(statement) && params.shouldDeclareGlobalBeInlined(params.currentModule, statement)) {
            result.statements.push(statement);
            continue;
        }
        if (ts.isExportAssignment(statement) && statement.isExportEquals && params.currentModule.type === 2 /* ShouldBeImported */) {
            updateResultForImportedEqExportAssignment(statement, params, result);
            continue;
        }
        if (!params.isStatementUsed(statement)) {
            logger_1.verboseLog("Skip file member: " + statement.getText().replace(/(\n|\r)/g, '').slice(0, 50) + "...");
            continue;
        }
        switch (params.currentModule.type) {
            case 3 /* ShouldBeReferencedAsTypes */:
                addTypesReference(params.currentModule.typesLibraryName, result.typesReferences);
                break;
            case 2 /* ShouldBeImported */:
                if (params.shouldStatementBeImported(statement)) {
                    addImport(statement, params.currentModule.libraryName, result.imports);
                }
                break;
            case 1 /* ShouldBeInlined */:
                result.statements.push(statement);
                break;
        }
    }
}
function updateResultForImportedEqExportAssignment(exportAssignment, params, result) {
    var moduleDeclarations = params.getDeclarationsForExportedAssignment(exportAssignment)
        .filter(typescript_helpers_1.isNamespaceStatement)
        .filter(function (s) { return s.getSourceFile() === exportAssignment.getSourceFile(); });
    // if we have `export =` somewhere so we can decide that every declaration of exported symbol in this way
    // is "part of the exported module" and we need to update result according every member of each declaration
    // but treat they as current module (we do not need to update module info)
    for (var _i = 0, moduleDeclarations_1 = moduleDeclarations; _i < moduleDeclarations_1.length; _i++) {
        var moduleDeclaration = moduleDeclarations_1[_i];
        if (moduleDeclaration.body === undefined || !ts.isModuleBlock(moduleDeclaration.body)) {
            continue;
        }
        updateResult(__assign({}, params, { statements: moduleDeclaration.body.statements }), result);
    }
}
function updateResultForModuleDeclaration(moduleDecl, params, result) {
    if (params.currentModule.type === 0 /* ShouldNotBeUsed */) {
        return;
    }
    if (moduleDecl.body === undefined || !ts.isModuleBlock(moduleDecl.body)) {
        return;
    }
    var moduleName = moduleDecl.name.text;
    var moduleFileName = resolveModuleFileName(params.currentModule.fileName, moduleName);
    var moduleInfo = params.getModuleInfo(moduleFileName);
    if (moduleInfo.type === 0 /* ShouldNotBeUsed */) {
        return;
    }
    // if we have declaration of external module inside internal one
    // we need to just add it to result without any processing
    if (!params.currentModule.isExternal && moduleInfo.isExternal) {
        result.statements.push(moduleDecl);
        return;
    }
    updateResult(__assign({}, params, { currentModule: moduleInfo, statements: moduleDecl.body.statements }), result);
}
function resolveModuleFileName(currentFileName, moduleName) {
    return moduleName.startsWith('.') ? path.join(currentFileName, '..', moduleName) : "node_modules/" + moduleName + "/";
}
function addTypesReference(library, typesReferences) {
    if (!typesReferences.has(library)) {
        logger_1.normalLog("Library \"" + library + "\" will be added via reference directive");
        typesReferences.add(library);
    }
}
function addImport(statement, library, imports) {
    if (statement.name === undefined) {
        throw new Error("Import/usage unnamed declaration: " + statement.getText());
    }
    var libraryImports = imports.get(library);
    if (libraryImports === undefined) {
        libraryImports = new Set();
        imports.set(library, libraryImports);
    }
    var importName = statement.name.getText();
    if (!libraryImports.has(importName)) {
        logger_1.normalLog("Adding import with name \"" + importName + "\" for library \"" + library + "\"");
        libraryImports.add(importName);
    }
}
function getRootSourceFile(program) {
    var rootFiles = program.getRootFileNames();
    if (rootFiles.length !== 1) {
        logger_1.verboseLog("Root files:\n  " + rootFiles.join('\n  '));
        throw new Error("There is not one root file - " + rootFiles.length);
    }
    var sourceFileName = rootFiles[0];
    var sourceFile = program.getSourceFile(sourceFileName);
    if (sourceFile === undefined) {
        throw new Error("Cannot get source file for root file " + sourceFileName);
    }
    return sourceFile;
}
function isDeclarationExported(exportedSymbols, typeChecker, declaration) {
    if (declaration.name === undefined) {
        return false;
    }
    var declarationSymbol = typeChecker.getSymbolAtLocation(declaration.name);
    return exportedSymbols.some(function (rootExport) { return rootExport === declarationSymbol; });
}
function isNodeUsed(node, rootFileExports, typesUsageEvaluator, typeChecker) {
    if (typescript_helpers_1.isNodeNamedDeclaration(node)) {
        return rootFileExports.some(function (rootExport) { return typesUsageEvaluator.isTypeUsedBySymbol(node, rootExport); });
    }
    else if (ts.isVariableStatement(node)) {
        return node.declarationList.declarations.some(function (declaration) {
            return isDeclarationExported(rootFileExports, typeChecker, declaration);
        });
    }
    return false;
}
function shouldNodeBeImported(node, rootFileExports, typesUsageEvaluator) {
    var symbolsUsingNode = typesUsageEvaluator.getSymbolsUsingNode(node);
    if (symbolsUsingNode === null) {
        throw new Error('Something went wrong - value cannot be null');
    }
    // we should import only symbols which are used in types directly
    return Array.from(symbolsUsingNode).some(function (symbol) {
        var symbolsDeclarations = getDeclarationsForSymbol(symbol);
        if (symbolsDeclarations.length === 0 || symbolsDeclarations.every(isDeclarationFromExternalModule)) {
            return false;
        }
        return rootFileExports.some(function (rootSymbol) { return typesUsageEvaluator.isSymbolUsedBySymbol(symbol, rootSymbol); });
    });
}
function getDeclarationsForSymbol(symbol) {
    var result = [];
    if (symbol.valueDeclaration !== undefined) {
        result.push(symbol.valueDeclaration);
    }
    if (symbol.declarations !== undefined) {
        result.push.apply(result, symbol.declarations);
    }
    return result;
}
function isDeclarationFromExternalModule(node) {
    return node_modules_helpers_1.getLibraryName(node.getSourceFile().fileName) !== null;
}