tslint-ban-snippets/dist/tslint-ban-snippets.umd.js

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('tslint')) :
    typeof define === 'function' && define.amd ? define(['exports', 'tslint'], factory) :
    (factory((global.tslintBanSnippets = {}),global.Lint));
}(this, (function (exports,Lint) { 'use strict';

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */
    /* global Reflect, Promise */

    var extendStatics = function(d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };

    function __extends(d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }

    var BAN_SNIPPETS_RULE_ID = "tsl-ban-snippets";

    var SNIPPETS_PROP = "snippets";
    var REGEX_SNIPPETS_PROP = "regexSnippets";
    var ConfigFactory;
    (function (ConfigFactory) {
        function createForBanSnippetsRule(options) {
            var config = createFromArguments(options, BAN_SNIPPETS_RULE_ID);
            validate(config, "banned", BAN_SNIPPETS_RULE_ID);
            config.banned.forEach(function (b) { return validateSnippetsList(b, BAN_SNIPPETS_RULE_ID); });
            return config;
        }
        ConfigFactory.createForBanSnippetsRule = createForBanSnippetsRule;
        function validate(config, prop, ruleId) {
            if (!hasProp(config, prop)) {
                throw new Error("invalid config for rule " + ruleId + " - " + prop + " is missing");
            }
        }
        function hasProp(config, prop) {
            return config[prop] !== undefined;
        }
        function validateSnippetsList(config, ruleId) {
            // either snippets OR regexSnippets is required
            var hasSnippets = hasProp(config, SNIPPETS_PROP);
            var hasRegexSnippets = hasProp(config, REGEX_SNIPPETS_PROP);
            var isValid = hasSnippets || hasRegexSnippets;
            var hasBoth = hasSnippets && hasRegexSnippets;
            if (!isValid || hasBoth) {
                throw new Error("invalid config for rule " + ruleId + " - either " + SNIPPETS_PROP + " or " + REGEX_SNIPPETS_PROP + " must be set");
            }
        }
        function createFromArguments(options, ruleId) {
            var args = options.ruleArguments;
            if (args.length !== 1) {
                throw new Error("tslint rule is misconfigured (" + ruleId + ") - options.ruleArguments length is " + args.length);
            }
            var config = args[0];
            return config;
        }
    })(ConfigFactory || (ConfigFactory = {}));

    var GeneralRuleUtils;
    (function (GeneralRuleUtils) {
        function buildFailureString(message, ruleId) {
            // include the rule ID, to make it easier to disable
            return message + " (" + ruleId + ")";
        }
        GeneralRuleUtils.buildFailureString = buildFailureString;
        function isFileInPaths(filePath, paths) {
            return paths.some(function (path) { return filePath.indexOf(path) >= 0; });
        }
        GeneralRuleUtils.isFileInPaths = isFileInPaths;
    })(GeneralRuleUtils || (GeneralRuleUtils = {}));

    var Rule = /** @class */ (function (_super) {
        __extends(Rule, _super);
        function Rule() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        Rule.prototype.apply = function (sourceFile) {
            var config = ConfigFactory.createForBanSnippetsRule(this.getOptions());
            var walker = new StatementsWalker(sourceFile, this.getOptions(), config);
            this.applyWithWalker(walker);
            return walker.getFailures();
        };
        return Rule;
    }(Lint.Rules.AbstractRule));
    var StatementsWalker = /** @class */ (function (_super) {
        __extends(StatementsWalker, _super);
        function StatementsWalker(sourceFile, options, config) {
            var _this = _super.call(this, sourceFile, options) || this;
            _this.config = config;
            return _this;
        }
        StatementsWalker.prototype.visitReturnStatement = function (node) {
            this.visitSomeNode(node);
        };
        StatementsWalker.prototype.visitBinaryExpression = function (node) {
            this.visitSomeNode(node);
            _super.prototype.visitBinaryExpression.call(this, node);
        };
        StatementsWalker.prototype.visitCallExpression = function (node) {
            this.visitSomeNode(node);
            _super.prototype.visitCallExpression.call(this, node);
        };
        StatementsWalker.prototype.visitDebuggerStatement = function (node) {
            this.visitSomeNode(node);
            _super.prototype.visitDebuggerStatement.call(this, node);
        };
        StatementsWalker.prototype.visitSomeNode = function (node) {
            var _this = this;
            var text = node.getText();
            var relevantBanned = this.getRelevantBanned();
            relevantBanned.forEach(function (banned) {
                if (banned.snippets) {
                    _this.checkBannedSnippet(banned.snippets, text, node, banned.message);
                }
                else if (banned.regexSnippets) {
                    _this.checkRegexBannedSnippet(banned.regexSnippets, text, node, banned.message);
                }
                else {
                    throw new Error("Invalid config? No snippets and no regex-snippets");
                }
            });
        };
        StatementsWalker.prototype.checkBannedSnippet = function (snippets, text, node, message) {
            var bannedCodeFound = snippets.filter(function (bannedSnippet) { return text.indexOf(bannedSnippet) >= 0; });
            if (bannedCodeFound.length > 0) {
                this.failRule(node, bannedCodeFound, message);
            }
        };
        StatementsWalker.prototype.checkRegexBannedSnippet = function (regexSnippets, text, node, message) {
            var bannedCodeFound = regexSnippets.filter(function (regexSnippet) {
                var regex = new RegExp(regexSnippet);
                return regex.test(text);
            });
            if (bannedCodeFound.length > 0) {
                this.failRule(node, bannedCodeFound, message);
            }
        };
        StatementsWalker.prototype.failRule = function (node, bannedCodeFound, message) {
            var failureNode = node.getFirstToken() || node;
            this.addFailureAtNode(failureNode, GeneralRuleUtils.buildFailureString(message || "Do not use banned code '" + bannedCodeFound.join("' or '") + "'.", BAN_SNIPPETS_RULE_ID));
        };
        StatementsWalker.prototype.getRelevantBanned = function () {
            var sourceFilePath = this.getSourceFile().fileName;
            return this.config.banned.filter(function (b) {
                return (!b.includePaths ||
                    GeneralRuleUtils.isFileInPaths(sourceFilePath, b.includePaths)) &&
                    (!b.excludePaths || !GeneralRuleUtils.isFileInPaths(sourceFilePath, b.excludePaths));
            });
        };
        return StatementsWalker;
    }(Lint.RuleWalker));

    exports.Rule = Rule;

    Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=tslint-ban-snippets.umd.js.map