tslint-import-rules/dist/rules/tirSpacesWithinImportRule.js

Set of TSLint rules that help validate proper imports.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
var Lint = require("tslint");
var nonSpaceSymbolPattern = /\S/;
var Rule = (function (_super) {
    tslib_1.__extends(Rule, _super);
    function Rule() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    Rule.prototype.apply = function (sourceFile) {
        return this.applyWithWalker(new RuleWalker(sourceFile, this.getOptions()));
    };
    return Rule;
}(Lint.Rules.AbstractRule));
exports.Rule = Rule;
var RuleWalker = (function (_super) {
    tslib_1.__extends(RuleWalker, _super);
    function RuleWalker(sourceFile, options) {
        var _this = _super.call(this, sourceFile, options) || this;
        _this.sourceText = sourceFile.getText();
        return _this;
    }
    RuleWalker.prototype.addSpacesFailure = function (node, count, beforeBracket) {
        var absCount = Math.abs(count);
        var spacesText = absCount + " space" + (absCount > 1 ? 's' : '');
        var positionText = beforeBracket ? "before '}'" : "after '{'";
        this.addFailureAtNode(node, (count > 0 ? 'Unexpected' : 'Expected') + " " + spacesText + " " + positionText);
    };
    RuleWalker.prototype.testCharAndCollectSpaces = function (ch, node, expectedSpacesCount, actualSpacesCount, beforeBracket) {
        if (ch === '\n') {
            if (actualSpacesCount) {
                this.addSpacesFailure(node, actualSpacesCount, beforeBracket);
            }
            return;
        }
        if (nonSpaceSymbolPattern.test(ch)) {
            var spacesDiff = actualSpacesCount - expectedSpacesCount;
            if (spacesDiff !== 0) {
                this.addSpacesFailure(node, spacesDiff, beforeBracket);
            }
            return;
        }
        return actualSpacesCount + 1;
    };
    RuleWalker.prototype.visitImportDeclaration = function (node) {
        var importClause = node.importClause;
        if (importClause) {
            var options = this.getOptions();
            var count = options[0] === 'never' ? 0 : Object.assign({ count: 1 }, options[1]).count;
            var start = importClause.getStart();
            var end = importClause.getEnd();
            var spacesCount = 0;
            var hasOpenedBracket = false;
            var hasClosedBracket = false;
            for (var i = start; i < end; i++) {
                var ch = this.sourceText[i];
                if (!hasOpenedBracket && ch === '{') {
                    hasOpenedBracket = true;
                }
                else if (hasOpenedBracket) {
                    spacesCount = this.testCharAndCollectSpaces(ch, importClause, count, spacesCount);
                    if (spacesCount === undefined) {
                        break;
                    }
                }
            }
            spacesCount = 0;
            for (var i = end - 1; i > start; i--) {
                var ch = this.sourceText[i];
                if (!hasClosedBracket && ch === '}') {
                    hasClosedBracket = true;
                }
                else if (hasClosedBracket) {
                    spacesCount = this.testCharAndCollectSpaces(ch, importClause, count, spacesCount, true);
                    if (spacesCount === undefined) {
                        break;
                    }
                }
            }
        }
        _super.prototype.visitImportDeclaration.call(this, node);
    };
    return RuleWalker;
}(Lint.RuleWalker));