rxjs-tslint-rules/dist/rules/rxjsNoIgnoredErrorRule.js

TSLint rules for RxJS

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Walker = exports.Rule = void 0;
var tslib_1 = require("tslib");
var Lint = tslib_1.__importStar(require("tslint"));
var tsutils = tslib_1.__importStar(require("tsutils"));
var util_1 = require("../support/util");
var Rule = (function (_super) {
    tslib_1.__extends(Rule, _super);
    function Rule() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    Rule.prototype.applyWithProgram = function (sourceFile, program) {
        return this.applyWithWalker(new Walker(sourceFile, this.getOptions(), program));
    };
    Rule.metadata = {
        description: "Disallows the calling of subscribe without specifying an error handler.",
        options: null,
        optionsDescription: "Not configurable.",
        requiresTypeInfo: true,
        ruleName: "rxjs-no-ignored-error",
        type: "functionality",
        typescriptOnly: true,
    };
    Rule.FAILURE_STRING = "Calling subscribe without an error handler is forbidden";
    return Rule;
}(Lint.Rules.TypedRule));
exports.Rule = Rule;
var Walker = (function (_super) {
    tslib_1.__extends(Walker, _super);
    function Walker() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    Walker.prototype.visitCallExpression = function (node) {
        var expression = node.expression;
        if (tsutils.isPropertyAccessExpression(expression)) {
            var name_1 = expression.name.getText();
            var typeChecker = this.getTypeChecker();
            var type = typeChecker.getTypeAtLocation(expression.expression);
            if (name_1 === "subscribe" &&
                util_1.isReferenceType(type) &&
                util_1.couldBeType(type, "Observable") &&
                node.arguments.length &&
                this.nodeIsLikelyAFunction(node.arguments[0]) &&
                node.arguments.length < 2) {
                this.addFailureAtNode(expression.name, Rule.FAILURE_STRING);
            }
        }
        _super.prototype.visitCallExpression.call(this, node);
    };
    Walker.prototype.nodeIsLikelyAFunction = function (node) {
        if (tsutils.isArrowFunction(node) || tsutils.isFunctionExpression(node)) {
            return true;
        }
        var typeChecker = this.getTypeChecker();
        var type = typeChecker.getTypeAtLocation(node);
        return util_1.couldBeFunction(type);
    };
    return Walker;
}(Lint.ProgramAwareRuleWalker));
exports.Walker = Walker;