tslint-origin-ordered-imports-rule/dist/originOrderedImportsRule.js

tslint rule to check order of imports

"use strict";
var __extends = (this && this.__extends) || (function () {
    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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
    return cooked;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Rule = exports.BlankLinesOption = void 0;
var Lint = require("tslint");
var modulesOrder_1 = require("./modulesOrder");
var walker_1 = require("./walker");
var utils_1 = require("./utils");
var BlankLinesOption;
(function (BlankLinesOption) {
    BlankLinesOption["AnyNumber"] = "any-number-of-blank-lines";
    BlankLinesOption["No"] = "no-blank-lines";
    BlankLinesOption["One"] = "one-blank-line";
    BlankLinesOption["AtLeastOne"] = "at-least-one-blank-line";
})(BlankLinesOption = exports.BlankLinesOption || (exports.BlankLinesOption = {}));
var Rule = /** @class */ (function (_super) {
    __extends(Rule, _super);
    function Rule() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    Rule.prototype.apply = function (sourceFile) {
        var _a = this.ruleArguments, arg1 = _a[0], arg2 = _a[1];
        var blankLines = (function () {
            if (typeof arg1 === 'string') {
                return arg1;
            }
            return BlankLinesOption.AnyNumber;
        })();
        var modulesOrder = (function () {
            if (Array.isArray(arg1)) {
                return new modulesOrder_1.default(arg1);
            }
            if (Array.isArray(arg2)) {
                return new modulesOrder_1.default(arg2);
            }
            return new modulesOrder_1.default([
                modulesOrder_1.ModuleType.Lib,
                modulesOrder_1.ModuleType.User
            ]);
        })();
        var walker = new walker_1.default(sourceFile, this.ruleName, {
            blankLines: blankLines,
            modulesOrder: modulesOrder
        });
        return this.applyWithWalker(walker);
    };
    Rule.metadata = {
        ruleName: 'origin-ordered-imports',
        description: 'Strict order for imports ("Lib import" must be higher than "User import") + your own import groups defined by regexps.',
        rationale: 'Helps maintain a readable style in your codebase.',
        optionsDescription: Lint.Utils.dedent(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n            You can require having a blank line between import groups.\n            It's `", "` by default, you can use next options: ", "\n\n            Feel free to add your own import group or/and change the order of built-in ones.\n        "], ["\n            You can require having a blank line between import groups.\n            It's \\`", "\\` by default, you can use next options: ", "\n\n            Feel free to add your own import group or/and change the order of built-in ones.\n        "])), BlankLinesOption.AnyNumber, utils_1.values(BlankLinesOption).map(function (_) { return "`" + _ + "`"; }).join(', ')),
        options: [
            {
                type: 'string',
                enum: utils_1.values(BlankLinesOption)
            },
            {
                type: 'array',
                items: {
                    type: 'string',
                    items: {
                        oneOf: [
                            {
                                type: 'string',
                                enum: [modulesOrder_1.ModuleType.Lib, modulesOrder_1.ModuleType.User]
                            },
                            {
                                type: 'string' // regexp
                            }
                        ]
                    }
                }
            }
        ],
        optionExamples: [
            [true],
            [true, BlankLinesOption.One],
            [
                true,
                [
                    '^@.+',
                ]
            ],
            [
                true,
                BlankLinesOption.One,
                [
                    modulesOrder_1.ModuleType.Lib,
                    '^@.+',
                    modulesOrder_1.ModuleType.User
                ]
            ],
        ],
        type: 'typescript',
        typescriptOnly: false,
        hasFix: false
    };
    return Rule;
}(Lint.Rules.AbstractRule));
exports.Rule = Rule;
var templateObject_1;
//# sourceMappingURL=../src/dist/originOrderedImportsRule.js.map