dts-bundle-generator/types-usage-evaluator.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ts = require("typescript");
var typescript_helpers_1 = require("./typescript-helpers");
var TypesUsageEvaluator = /** @class */ (function () {
    function TypesUsageEvaluator(files, typeChecker) {
        this.nodesParentsMap = new Map();
        this.typeChecker = typeChecker;
        this.computeUsages(files);
    }
    TypesUsageEvaluator.prototype.isTypeUsedBySymbol = function (typeNode, by) {
        if (typeNode.name === undefined) {
            // anon?
            return false;
        }
        return this.isSymbolUsedBySymbol(this.getSymbol(typeNode.name), by);
    };
    TypesUsageEvaluator.prototype.isSymbolUsedBySymbol = function (symbol, by) {
        return this.isSymbolUsedBySymbolImpl(this.getActualSymbol(symbol), this.getActualSymbol(by), new Set());
    };
    TypesUsageEvaluator.prototype.getSymbolsUsingNode = function (typeNode) {
        if (typeNode.name === undefined) {
            return null;
        }
        return this.nodesParentsMap.get(this.getSymbol(typeNode.name)) || null;
    };
    TypesUsageEvaluator.prototype.isSymbolUsedBySymbolImpl = function (fromSymbol, toSymbol, visitedSymbols) {
        if (fromSymbol === toSymbol) {
            return true;
        }
        var reachableNodes = this.nodesParentsMap.get(fromSymbol);
        if (reachableNodes) {
            for (var _i = 0, _a = Array.from(reachableNodes); _i < _a.length; _i++) {
                var symbol = _a[_i];
                if (visitedSymbols.has(symbol)) {
                    continue;
                }
                visitedSymbols.add(symbol);
                if (this.isSymbolUsedBySymbolImpl(symbol, toSymbol, visitedSymbols)) {
                    return true;
                }
            }
        }
        visitedSymbols.add(fromSymbol);
        return false;
    };
    TypesUsageEvaluator.prototype.computeUsages = function (files) {
        this.nodesParentsMap.clear();
        for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
            var file = files_1[_i];
            ts.forEachChild(file, this.computeUsageForNode.bind(this));
        }
    };
    TypesUsageEvaluator.prototype.computeUsageForNode = function (node) {
        if (typescript_helpers_1.isNodeNamedDeclaration(node) && node.name) {
            var childSymbol = this.getSymbol(node.name);
            this.computeUsagesRecursively(node, childSymbol);
        }
        else if (ts.isVariableStatement(node)) {
            for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) {
                var varDeclaration = _a[_i];
                this.computeUsageForNode(varDeclaration);
            }
        }
    };
    TypesUsageEvaluator.prototype.computeUsagesRecursively = function (parent, parentSymbol) {
        var queue = parent.getChildren();
        for (var _i = 0, queue_1 = queue; _i < queue_1.length; _i++) {
            var child = queue_1[_i];
            if (child.kind === ts.SyntaxKind.JSDocComment) {
                continue;
            }
            queue.push.apply(queue, child.getChildren());
            if (ts.isIdentifier(child)) {
                var childSymbol = this.getSymbol(child);
                var symbols = this.nodesParentsMap.get(childSymbol);
                if (symbols === undefined) {
                    symbols = new Set();
                    this.nodesParentsMap.set(childSymbol, symbols);
                }
                // to avoid infinite recursion
                if (childSymbol !== parentSymbol) {
                    symbols.add(parentSymbol);
                }
            }
        }
    };
    TypesUsageEvaluator.prototype.getSymbol = function (node) {
        var nodeSymbol = this.typeChecker.getSymbolAtLocation(node);
        if (nodeSymbol === undefined) {
            throw new Error("Cannot find symbol for node: " + node.getText());
        }
        return this.getActualSymbol(nodeSymbol);
    };
    TypesUsageEvaluator.prototype.getActualSymbol = function (symbol) {
        return typescript_helpers_1.getActualSymbol(symbol, this.typeChecker);
    };
    return TypesUsageEvaluator;
}());
exports.TypesUsageEvaluator = TypesUsageEvaluator;