@daldalso/eslint-plugin 1.2.0

package/dist/rules/key-quotation-style.js

@@ -0,0 +1,150 @@
+"use strict";
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@typescript-eslint/utils");
+var simpleNamePattern = /^\w+$/;
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "layout",
+        fixable: "code",
+        messages: {
+            'for-type-alias': "Simple key name in a type alias should be quoted with `{{quotation}}`.",
+            'for-interface': "Simple key name in an interface should be quoted with `{{quotation}}`.",
+            'for-object': "Simple key name in an object should be quoted with `{{quotation}}`."
+        },
+        schema: [{
+                type: "object",
+                properties: {
+                    typeAlias: { type: "string", enum: ["none", "'", "\""] },
+                    object: { type: "string", enum: ["none", "'", "\""] },
+                    interface: { type: "string", enum: ["none", "'", "\""] }
+                }
+            }]
+    },
+    defaultOptions: [{
+            forTypeAlias: "'",
+            forObject: "none",
+            forInterface: "none"
+        }],
+    create: function (context, _a) {
+        var _b = _a[0], forTypeAlias = _b.forTypeAlias, forObject = _b.forObject, forInterface = _b.forInterface;
+        var isSimple = function (node) {
+            switch (node.type) {
+                case utils_1.AST_NODE_TYPES.Identifier: return simpleNamePattern.test(node.name);
+                case utils_1.AST_NODE_TYPES.Literal: return typeof node.value === "string" && simpleNamePattern.test(node.value);
+            }
+            return false;
+        };
+        var getKeyQuotationStyle = function (node) {
+            if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+                if (!simpleNamePattern.test(node.name)) {
+                    return null;
+                }
+                return { style: "none", name: node.name };
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+                if (!simpleNamePattern.test(node.value)) {
+                    return null;
+                }
+                return { style: node.raw[0], name: node.value };
+            }
+            return null;
+        };
+        var checkMembers = function (list, as, messageId) {
+            var _loop_1 = function (v) {
+                if (v.computed) {
+                    return { value: void 0 };
+                }
+                var style = getKeyQuotationStyle(v.key);
+                if (style === null) {
+                    return { value: void 0 };
+                }
+                if (style.style === as) {
+                    return { value: void 0 };
+                }
+                context.report({
+                    node: v.key,
+                    messageId: messageId,
+                    data: { quotation: as },
+                    fix: function (fixer) {
+                        var actualAs;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    actualAs = as === "none" ? "" : as;
+                                    return [4 /*yield*/, fixer.replaceText(v.key, actualAs + style.name + actualAs)];
+                                case 1:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }
+                });
+            };
+            for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
+                var v = list_1[_i];
+                var state_1 = _loop_1(v);
+                if (typeof state_1 === "object")
+                    return state_1.value;
+            }
+        };
+        return {
+            TSTypeLiteral: function (node) {
+                var filteredMembers = node.members.filter(function (v) { return v.type === utils_1.AST_NODE_TYPES.TSPropertySignature; });
+                if (filteredMembers.length <= 1) {
+                    return;
+                }
+                if (!filteredMembers.every(function (v) { return isSimple(v.key); })) {
+                    return;
+                }
+                checkMembers(filteredMembers, forTypeAlias, 'for-type-alias');
+            },
+            TSInterfaceBody: function (node) {
+                var filteredMembers = node.body.filter(function (v) { return v.type === utils_1.AST_NODE_TYPES.TSPropertySignature; });
+                if (filteredMembers.length <= 1) {
+                    return;
+                }
+                if (!filteredMembers.every(function (v) { return isSimple(v.key); })) {
+                    return;
+                }
+                checkMembers(filteredMembers, forInterface, 'for-interface');
+            },
+            ObjectExpression: function (node) {
+                var filteredMembers = node.properties.filter(function (v) { return v.type === utils_1.AST_NODE_TYPES.Property; });
+                if (filteredMembers.length <= 1) {
+                    return;
+                }
+                if (!filteredMembers.every(function (v) { return isSimple(v.key); })) {
+                    return;
+                }
+                checkMembers(filteredMembers, forObject, 'for-object');
+            }
+        };
+    }
+});

package/dist/rules/lone-semicolon-indent.js

@@ -0,0 +1,92 @@
+"use strict";
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@typescript-eslint/utils");
+var code_1 = require("../utils/code");
+var patterns_1 = require("../utils/patterns");
+var text_1 = require("../utils/text");
+var loneSemicolonPattern = /^\s*;$/;
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            'default': "Lone semicolon should be indented less than the previous line."
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create: function (context) {
+        var sourceCode = context.getSourceCode();
+        return {
+            Program: function () {
+                var _loop_1 = function (i) {
+                    if (!loneSemicolonPattern.test(sourceCode.lines[i])) {
+                        return "continue";
+                    }
+                    var prevIndentation = (0, code_1.getIndentation)(sourceCode, i);
+                    var indentation = (0, code_1.getIndentation)(sourceCode, i + 1);
+                    if (prevIndentation.length > indentation.length) {
+                        return "continue";
+                    }
+                    var semicolon = sourceCode.getTokenByRangeStart(sourceCode.lineStartIndices[i] + indentation.length);
+                    if (!semicolon) {
+                        throw Error("There must exist one semicolon");
+                    }
+                    var isPrevLineClosing = patterns_1.closingLinePattern.test(sourceCode.lines[i - 1]);
+                    var prevToken = sourceCode.getTokenBefore(semicolon);
+                    context.report({
+                        node: semicolon,
+                        messageId: 'default',
+                        fix: function (fixer) {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!(isPrevLineClosing && prevToken)) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, fixer.replaceTextRange([prevToken.range[1], semicolon.range[0]], "")];
+                                    case 1:
+                                        _a.sent();
+                                        return [3 /*break*/, 4];
+                                    case 2: return [4 /*yield*/, fixer.removeRange([semicolon.range[0] - text_1.INDENTATION_UNIT.length, semicolon.range[0]])];
+                                    case 3:
+                                        _a.sent();
+                                        _a.label = 4;
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }
+                    });
+                };
+                for (var i = 1; i < sourceCode.lines.length; i++) {
+                    _loop_1(i);
+                }
+            }
+        };
+    }
+});

package/dist/rules/multiline-expression-spacing.js

@@ -0,0 +1,130 @@
+"use strict";
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@typescript-eslint/utils");
+var patterns_1 = require("../utils/patterns");
+var code_1 = require("../utils/code");
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            'for-conditional-expression': "Multiline conditional expression should finish the line.",
+            'for-call-expression': "Multiline function call should finish the line.",
+            'for-call-expression-consistency': "Both the parentheses of a function call should be indented equally.",
+            'for-member-expression': "Multiline property access should finish the line.",
+            'for-binary-expression': "Multiline binary expression should finish the line."
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create: function (context) {
+        var sourceCode = context.getSourceCode();
+        var checkExpression = function (node, messageId) {
+            var isMultiline = node.loc.start.line !== node.loc.end.line;
+            if (!isMultiline) {
+                return;
+            }
+            var chunk = sourceCode.lines[node.loc.end.line - 1].match(patterns_1.closingLinePattern);
+            if (chunk && (0, code_1.getIndentation)(sourceCode, node.loc.start.line) === chunk[1]) {
+                return;
+            }
+            var next = sourceCode.getTokenAfter(node);
+            if ((next === null || next === void 0 ? void 0 : next.loc.start.line) !== node.loc.end.line) {
+                return;
+            }
+            context.report({
+                node: next,
+                messageId: messageId,
+                fix: function (fixer) {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, fixer.insertTextAfter(node, "\n")];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }
+            });
+        };
+        return {
+            ConditionalExpression: function (node) {
+                checkExpression(node, 'for-conditional-expression');
+            },
+            CallExpression: function (node) {
+                var openingParenthesis = sourceCode.getTokenAfter(node.callee);
+                var closingParenthesis = sourceCode.getLastToken(node);
+                if (!openingParenthesis || !closingParenthesis) {
+                    return;
+                }
+                var openingLineIndentation = (0, code_1.getIndentation)(sourceCode, openingParenthesis.loc.start.line);
+                var closingLineIndentation = (0, code_1.getIndentation)(sourceCode, closingParenthesis.loc.end.line);
+                checkExpression(node, 'for-call-expression');
+                if (openingLineIndentation !== closingLineIndentation) {
+                    context.report({
+                        node: closingParenthesis,
+                        messageId: "for-call-expression-consistency",
+                        fix: function (fixer) {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, fixer.insertTextBefore(closingParenthesis, "\n" + openingLineIndentation)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }
+                    });
+                }
+            },
+            MemberExpression: function (node) {
+                var _a;
+                if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) === utils_1.AST_NODE_TYPES.CallExpression) {
+                    return;
+                }
+                checkExpression(node, 'for-member-expression');
+            },
+            'BinaryExpression, LogicalExpression': function (node) {
+                var leftEnd = sourceCode.getLastToken(node.left);
+                var rightStart = sourceCode.getFirstToken(node.right);
+                if (!leftEnd || !rightStart) {
+                    return;
+                }
+                if (leftEnd.loc.end.line === rightStart.loc.start.line) {
+                    return;
+                }
+                checkExpression(node, 'for-binary-expression');
+            },
+            'TSUnionType, TSIntersectionType': function (node) {
+                checkExpression(node, 'for-binary-expression');
+            }
+        };
+    }
+});

package/dist/rules/no-class-expression.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@typescript-eslint/utils");
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "layout",
+        messages: {
+            'default': "Class expression is not allowed."
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create: function (context) {
+        return {
+            ClassExpression: function (node) {
+                context.report({ node: node, messageId: "default" });
+            }
+        };
+    }
+});

package/dist/rules/no-type-name-affix.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@typescript-eslint/utils");
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "layout",
+        fixable: "code",
+        messages: {
+            'for-type-alias': "Type alias name should not be `{{pattern}}`.",
+            'for-interface': "Interface name should not be `{{pattern}}`."
+        },
+        schema: [{
+                type: "object",
+                properties: {
+                    invalidTypeAliasNamePattern: { type: "string" },
+                    invalidInterfaceNamePattern: { type: "string" },
+                    validNames: {
+                        type: "array",
+                        items: { type: "string" }
+                    }
+                }
+            }]
+    },
+    defaultOptions: [{
+            invalidTypeAliasNamePattern: /[^A-Z]T(?:ype)?$/.source,
+            invalidInterfaceNamePattern: /^I[A-Z][^A-Z]/.source,
+            validNames: []
+        }],
+    create: function (context, _a) {
+        var _b = _a[0], invalidTypeAliasNamePatternString = _b.invalidTypeAliasNamePattern, invalidInterfaceNamePatternString = _b.invalidInterfaceNamePattern, validNames = _b.validNames;
+        var invalidTypeAliasNamePattern = new RegExp(invalidTypeAliasNamePatternString);
+        var invalidInterfaceNamePattern = new RegExp(invalidInterfaceNamePatternString);
+        return {
+            TSTypeAliasDeclaration: function (node) {
+                if (!invalidTypeAliasNamePattern.test(node.id.name)) {
+                    return;
+                }
+                if (validNames.includes(node.id.name)) {
+                    return;
+                }
+                context.report({
+                    node: node.id,
+                    messageId: "for-type-alias",
+                    data: { pattern: invalidTypeAliasNamePatternString }
+                });
+            },
+            TSInterfaceDeclaration: function (node) {
+                if (!invalidInterfaceNamePattern.test(node.id.name)) {
+                    return;
+                }
+                if (validNames.includes(node.id.name)) {
+                    return;
+                }
+                context.report({
+                    node: node.id,
+                    messageId: "for-interface",
+                    data: { pattern: invalidInterfaceNamePatternString }
+                });
+            }
+        };
+    }
+});

package/dist/rules/no-unsafe-unquoted-key.js

@@ -0,0 +1,80 @@
+"use strict";
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@typescript-eslint/utils");
+var type_1 = require("../utils/type");
+var propertyPattern = /\.\s*(\w+)$/;
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "layout",
+        hasSuggestions: true,
+        messages: {
+            'default': "Access to the unsafe key `{{key}}` should use a string literal."
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create: function (context) {
+        var sourceCode = context.getSourceCode();
+        (0, type_1.useTypeChecker)(context);
+        return {
+            MemberExpression: function (node) {
+                if (node.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                if (node.computed) {
+                    return;
+                }
+                var type = (0, type_1.getTSTypeByNode)(context, node.object).getNonNullableType();
+                var properties = context.settings.typeChecker.getPropertyOfType(type, node.property.name);
+                if (properties) {
+                    return;
+                }
+                context.report({
+                    node: node.property,
+                    messageId: 'default',
+                    data: { key: node.property.name },
+                    suggest: [{
+                            messageId: 'default',
+                            fix: function (fixer) {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, fixer.replaceText(node, sourceCode.getText(node).replace(propertyPattern, "['$1']"))];
+                                        case 1:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }
+                        }]
+                });
+            }
+        };
+    }
+});

package/dist/rules/no-useless-template-literal.js

@@ -0,0 +1,81 @@
+"use strict";
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@typescript-eslint/utils");
+var backtickPattern = /^`|`$/g;
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "suggestion",
+        fixable: "code",
+        messages: {
+            'default': "Template literal should contain at least one expression."
+        },
+        schema: [{
+                type: "object",
+                properties: {
+                    to: { type: "string", enum: ['\'', '"'] }
+                }
+            }]
+    },
+    defaultOptions: [{
+            to: '"'
+        }],
+    create: function (context, _a) {
+        var to = _a[0].to;
+        var sourceCode = context.getSourceCode();
+        return {
+            TemplateLiteral: function (node) {
+                var _a;
+                if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) === utils_1.AST_NODE_TYPES.TaggedTemplateExpression) {
+                    return;
+                }
+                if (node.expressions.length) {
+                    return;
+                }
+                if (node.loc.start.line !== node.loc.end.line) {
+                    return;
+                }
+                context.report({
+                    node: node,
+                    messageId: "default",
+                    fix: function (fixer) {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, fixer.replaceText(node, sourceCode.getText(node).replace(backtickPattern, to))];
+                                case 1:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }
+                });
+            }
+        };
+    }
+});

package/dist/rules/one-exported-react-component.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@typescript-eslint/utils");
+var patterns_1 = require("../utils/patterns");
+var type_1 = require("../utils/type");
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "suggestion",
+        messages: {
+            'default': "Only one React component is allowed to be exported in a file."
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create: function (context) {
+        var alreadyExported = false;
+        (0, type_1.useTypeChecker)(context);
+        return {
+            ExportNamedDeclaration: function (node) {
+                var _a;
+                if (((_a = node.declaration) === null || _a === void 0 ? void 0 : _a.type) !== utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                    return;
+                }
+                for (var _i = 0, _b = node.declaration.declarations; _i < _b.length; _i++) {
+                    var v = _b[_i];
+                    var tsType = (0, type_1.getTSTypeByNode)(context, v.id);
+                    if (!(0, type_1.isDOMReturningFunction)(context, tsType, patterns_1.domTypePatterns)) {
+                        continue;
+                    }
+                    if (!alreadyExported) {
+                        alreadyExported = true;
+                        continue;
+                    }
+                    context.report({ node: v, messageId: "default" });
+                }
+            },
+            ExportSpecifier: function (node) {
+                var tsType = (0, type_1.getTSTypeByNode)(context, node.local);
+                if (!(0, type_1.isDOMReturningFunction)(context, tsType, patterns_1.domTypePatterns)) {
+                    return;
+                }
+                if (!alreadyExported) {
+                    alreadyExported = true;
+                    return;
+                }
+                context.report({ node: node.local, messageId: "default" });
+            }
+        };
+    }
+});