@daldalso/eslint-plugin 1.2.0

package/dist/rules/parenthesis-spacing.js

@@ -0,0 +1,206 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 ast_spec_1 = require("@typescript-eslint/types/dist/generated/ast-spec");
+var utils_1 = require("@typescript-eslint/utils");
+var patterns_1 = require("../utils/patterns");
+var OBJECT_OR_ARRAY_TYPES = [
+    utils_1.AST_NODE_TYPES.ArrayExpression,
+    utils_1.AST_NODE_TYPES.ArrayPattern,
+    utils_1.AST_NODE_TYPES.ObjectExpression,
+    utils_1.AST_NODE_TYPES.ObjectPattern
+];
+var DIRECTION_TABLE = {
+    '[': "after",
+    '{': "after",
+    ']': "before",
+    '}': "before"
+};
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            'should': "Spacing required {{direction}} `{{token}}`.",
+            'should-not': "No spacing required {{direction}} `{{token}}`."
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create: function (context) {
+        var sourceCode = context.getSourceCode();
+        var isFirstCloserOfLine = function (closer) {
+            var line = sourceCode.lines[closer.loc.start.line - 1];
+            var chunk = line.match(patterns_1.closingLinePattern);
+            if (!chunk)
+                return false;
+            return closer.loc.start.column === chunk[0].length - 1;
+        };
+        var hasOnlyObjectOrArray = function (children) { return children.length === 1
+            && children[0] !== null
+            && OBJECT_OR_ARRAY_TYPES.includes(children[0].type); };
+        var getMessageIdWithData = function (token, shouldBeSpaced) {
+            var direction = DIRECTION_TABLE[token];
+            return {
+                messageId: shouldBeSpaced ? "should" : "should-not",
+                data: { direction: direction, token: token }
+            };
+        };
+        var checkLeadingSpace = function (from, token, shouldBeSpaced) {
+            var _a, _b;
+            var _c;
+            if (shouldBeSpaced === void 0) { shouldBeSpaced = false; }
+            var opener;
+            var payload;
+            if (from.type in ast_spec_1.AST_TOKEN_TYPES) {
+                _a = [from, sourceCode.getTokenAfter(from)], opener = _a[0], payload = _a[1];
+            }
+            else {
+                _b = sourceCode.getFirstTokens(from, { count: 2 }), opener = _b[0], payload = _b[1];
+            }
+            if (!payload) {
+                return;
+            }
+            if (shouldBeSpaced === Boolean((_c = sourceCode.isSpaceBetween) === null || _c === void 0 ? void 0 : _c.call(sourceCode, opener, payload))) {
+                return;
+            }
+            context.report(__assign(__assign({ node: opener }, getMessageIdWithData(token, shouldBeSpaced)), { fix: function (fixer) {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (!shouldBeSpaced) return [3 /*break*/, 2];
+                                return [4 /*yield*/, fixer.insertTextAfter(opener, " ")];
+                            case 1:
+                                _a.sent();
+                                return [3 /*break*/, 4];
+                            case 2: return [4 /*yield*/, fixer.removeRange([opener.range[1], payload.range[0]])];
+                            case 3:
+                                _a.sent();
+                                _a.label = 4;
+                            case 4: return [2 /*return*/];
+                        }
+                    });
+                } }));
+        };
+        var checkTrailingSpace = function (from, token, shouldBeSpaced) {
+            var _a, _b, _c;
+            var _d;
+            if (shouldBeSpaced === void 0) { shouldBeSpaced = false; }
+            var payload;
+            var closer;
+            if (from.type in ast_spec_1.AST_TOKEN_TYPES) {
+                _a = [sourceCode.getTokenBefore(from), from], payload = _a[0], closer = _a[1];
+            }
+            else if ('typeAnnotation' in from && from.typeAnnotation) {
+                _b = sourceCode.getTokensBefore(from.typeAnnotation, { count: 2 }), payload = _b[0], closer = _b[1];
+            }
+            else {
+                _c = sourceCode.getLastTokens(from, { count: 2 }), payload = _c[0], closer = _c[1];
+            }
+            if (!payload) {
+                return;
+            }
+            if (isFirstCloserOfLine(closer)) {
+                return;
+            }
+            if (shouldBeSpaced === Boolean((_d = sourceCode.isSpaceBetween) === null || _d === void 0 ? void 0 : _d.call(sourceCode, payload, closer))) {
+                return;
+            }
+            context.report(__assign(__assign({ node: closer }, getMessageIdWithData(token, shouldBeSpaced)), { fix: function (fixer) {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (!shouldBeSpaced) return [3 /*break*/, 2];
+                                return [4 /*yield*/, fixer.insertTextBefore(closer, " ")];
+                            case 1:
+                                _a.sent();
+                                return [3 /*break*/, 4];
+                            case 2: return [4 /*yield*/, fixer.removeRange([payload.range[1], closer.range[0]])];
+                            case 3:
+                                _a.sent();
+                                _a.label = 4;
+                            case 4: return [2 /*return*/];
+                        }
+                    });
+                } }));
+        };
+        return {
+            'ArrayExpression, ArrayPattern': function (node) {
+                if (!node.elements.length) {
+                    return;
+                }
+                var isMultiline = node.loc.start.line !== node.loc.end.line;
+                var only = hasOnlyObjectOrArray(node.elements);
+                checkLeadingSpace(node, "[", !only);
+                if (isMultiline) {
+                    checkTrailingSpace(node, "]", false);
+                }
+                else {
+                    checkTrailingSpace(node, "]", !only);
+                }
+            },
+            'ObjectExpression, ObjectPattern': function (node) {
+                if (!node.properties.length) {
+                    return;
+                }
+                var isMultiline = node.loc.start.line !== node.loc.end.line;
+                var only = hasOnlyObjectOrArray(node.properties);
+                checkLeadingSpace(node, "{", !only);
+                if (isMultiline) {
+                    checkTrailingSpace(node, "}", false);
+                }
+                else {
+                    checkTrailingSpace(node, "}", !only);
+                }
+            },
+            'ImportDeclaration, ExportNamedDeclaration': function (node) {
+                if (!node.specifiers.length) {
+                    return;
+                }
+                var opening = sourceCode.getTokenBefore(node.specifiers[0]);
+                var closing = sourceCode.getTokenAfter(node.specifiers[node.specifiers.length - 1]);
+                if (opening)
+                    checkLeadingSpace(opening, "{", true);
+                if (closing)
+                    checkTrailingSpace(closing, "}", true);
+            }
+        };
+    }
+});

package/dist/rules/prefer-const.js

@@ -0,0 +1,123 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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");
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "layout",
+        fixable: "code",
+        messages: {
+            'default': "`{{name}}` can be a constant."
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create: function (context) {
+        var sourceCode = context.getSourceCode();
+        var reassignedIdentifierTable = {};
+        var getKey = function (_a) {
+            var scope = _a.scope, name = _a.name;
+            return "".concat(scope.block.range[0], ",").concat(scope.block.range[1], "/").concat(name);
+        };
+        return {
+            Program: function () {
+                var variables = getReassignedVariables(context.getScope());
+                for (var _i = 0, variables_1 = variables; _i < variables_1.length; _i++) {
+                    var v = variables_1[_i];
+                    reassignedIdentifierTable[getKey(v)] = true;
+                }
+            },
+            VariableDeclaration: function (node) {
+                if (node.kind !== "let") {
+                    return;
+                }
+                var scope = context.getScope();
+                var kindToken = sourceCode.getFirstToken(node);
+                for (var _i = 0, _a = node.declarations; _i < _a.length; _i++) {
+                    var v = _a[_i];
+                    if (v.id.type !== utils_1.AST_NODE_TYPES.Identifier)
+                        continue;
+                    var variable = scope.set.get(v.id.name);
+                    if (variable && reassignedIdentifierTable[getKey(variable)])
+                        continue;
+                    context.report({
+                        node: v,
+                        messageId: "default",
+                        data: { name: v.id.name },
+                        fix: function (fixer) {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, fixer.replaceText(kindToken, "const")];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }
+                    });
+                }
+            }
+        };
+    }
+});
+function getReassignedVariables(scope, parentSet) {
+    var _a;
+    if (parentSet === void 0) { parentSet = {}; }
+    var R = [];
+    var set = __assign(__assign({}, parentSet), Object.fromEntries(scope.set.entries()));
+    for (var _i = 0, _b = scope.references; _i < _b.length; _i++) {
+        var v = _b[_i];
+        if (v.from !== scope)
+            continue;
+        if (((_a = v.identifier.parent) === null || _a === void 0 ? void 0 : _a.type) === utils_1.AST_NODE_TYPES.VariableDeclarator)
+            continue;
+        if (!v.isWrite())
+            continue;
+        var variable = set[v.identifier.name];
+        if (!variable)
+            continue;
+        R.push(variable);
+    }
+    for (var _c = 0, _d = scope.childScopes; _c < _d.length; _c++) {
+        var v = _d[_c];
+        R.push.apply(R, getReassignedVariables(v, set));
+    }
+    return R;
+}

package/dist/rules/return-type.js

@@ -0,0 +1,96 @@
+"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");
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "suggestion",
+        hasSuggestions: true,
+        messages: {
+            'for-method': "Method should have a return type annotation.",
+            'for-function': "Function with the simple return type `{{type}}` should have a return type annotation.",
+            'for-function/suggest/0': "Add a return type annotation"
+        },
+        schema: [{
+                type: "object",
+                properties: {
+                    simpleTypeMaxLength: { type: "integer" }
+                }
+            }]
+    },
+    defaultOptions: [{
+            simpleTypeMaxLength: 20
+        }],
+    create: function (context, _a) {
+        var simpleTypeMaxLength = _a[0].simpleTypeMaxLength;
+        (0, type_1.useTypeChecker)(context);
+        return {
+            MethodDefinition: function (node) {
+                if (node.value.returnType) {
+                    return;
+                }
+                if (node.kind === "constructor") {
+                    return;
+                }
+                if (node.kind === "set") {
+                    return;
+                }
+                context.report({ node: node, messageId: 'for-method' });
+            },
+            FunctionDeclaration: function (node) {
+                if (node.returnType) {
+                    return;
+                }
+                var returnType = (0, type_1.typeToString)(context, (0, type_1.getFunctionReturnType)(context, node));
+                if (returnType.length > simpleTypeMaxLength) {
+                    return;
+                }
+                context.report({
+                    node: node,
+                    messageId: 'for-function',
+                    data: { type: returnType },
+                    suggest: [{
+                            messageId: 'for-function/suggest/0',
+                            fix: function (fixer) {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, fixer.insertTextBefore(node.body, ":".concat(returnType.replace(/ /g, "")))];
+                                        case 1:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }
+                        }]
+                });
+            }
+        };
+    }
+});

package/dist/rules/semantic-quotes.js

@@ -0,0 +1,240 @@
+"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 ast_spec_1 = require("@typescript-eslint/types/dist/generated/ast-spec");
+var utils_1 = require("@typescript-eslint/utils");
+var patterns_1 = require("../utils/patterns");
+var type_1 = require("../utils/type");
+var quotes = ["'", "\"", "`"];
+var eventMethodNames = ["on", "once", "off", "emit", "addEventListener", "removeEventListener"];
+var quotePattern = /^["'`]|["'`]$/g;
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "layout",
+        fixable: "code",
+        messages: {
+            'from-keyish-name': "String literal for a key should be quoted with `'`.",
+            'from-valueish-name': "String literal for a value should be quoted with `\"`.",
+            'from-keyish-type': "String literal constrained by a finite set of values should be quoted with `'`.",
+            'from-valueish-type': "String literal not constrained by a finite set of values should be quoted with `\"`.",
+            'from-keyish-usage': "String literal used as a key should be quoted with `'`.",
+            'from-valueish-usage': "String literal used as a value should be quoted with `\"`.",
+            'from-event': "String literal used as an event name should be quoted with `'`.",
+            'from-generic': "String literal used as a generic type should be quoted with `'`."
+        },
+        schema: [{
+                type: "object",
+                properties: {
+                    keyishNamePattern: { type: "string" },
+                    valueishNamePattern: { type: "string" }
+                }
+            }]
+    },
+    defaultOptions: [{
+            keyishNamePattern: patterns_1.keyishNamePattern.source,
+            valueishNamePattern: patterns_1.valueishNamePattern.source
+        }],
+    create: function (context, _a) {
+        var _b = _a[0], keyishNamePatternString = _b.keyishNamePattern, valueishNamePatternString = _b.valueishNamePattern;
+        var keyishNamePattern = new RegExp(keyishNamePatternString);
+        var valueishNamePattern = new RegExp(valueishNamePatternString);
+        var sourceCode = context.getSourceCode();
+        var assertStringLiteral = function (node, as, messageId) {
+            if (node.type !== ast_spec_1.AST_NODE_TYPES.Literal) {
+                return;
+            }
+            if (!quotes.includes(node.raw[0])) {
+                return;
+            }
+            var target = as === "key" ? "'" : "\"";
+            if (node.raw[0].startsWith(target)) {
+                return;
+            }
+            context.report({
+                node: node,
+                messageId: messageId,
+                fix: function (fixer) {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, fixer.replaceText(node, sourceCode.getText(node).replace(quotePattern, target))];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }
+            });
+        };
+        var checkLiteral = function (symbol, node, ignoreKeyishUnion, isRest) {
+            if (keyishNamePattern.test(symbol.name)) {
+                assertStringLiteral(node, 'key', 'from-keyish-name');
+                return;
+            }
+            if (valueishNamePattern.test(symbol.name)) {
+                assertStringLiteral(node, 'value', 'from-valueish-name');
+                return;
+            }
+            if (ignoreKeyishUnion) {
+                assertStringLiteral(node, 'value', 'from-valueish-usage');
+                return;
+            }
+            var type = (0, type_1.getTSTypeBySymbol)(context, symbol, node).getNonNullableType();
+            var isKey;
+            if (isRest) {
+                var innerType = type.getNumberIndexType();
+                isKey = (innerType === null || innerType === void 0 ? void 0 : innerType.isStringLiteral()) || ((innerType === null || innerType === void 0 ? void 0 : innerType.isUnion()) && innerType.types.every(function (v) { return v.isStringLiteral(); }));
+            }
+            else {
+                isKey = type.isStringLiteral() || (type.isUnion() && type.types.every(function (v) { return v.isStringLiteral(); }));
+            }
+            if (isKey) {
+                assertStringLiteral(node, 'key', 'from-keyish-type');
+            }
+            else {
+                assertStringLiteral(node, 'value', 'from-valueish-type');
+            }
+        };
+        var checkObjectExpression = function (types, values) {
+            var typeMap = types.reduce(function (pv, v) {
+                pv[v.name] = v;
+                return pv;
+            }, {});
+            for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
+                var v = values_1[_i];
+                if (v.type !== ast_spec_1.AST_NODE_TYPES.Property)
+                    continue;
+                if (v.key.type !== ast_spec_1.AST_NODE_TYPES.Literal)
+                    continue;
+                if (typeof v.key.value !== "string")
+                    continue;
+                var keySymbol = typeMap[v.key.value];
+                assertStringLiteral(v.key, 'key', 'from-keyish-usage');
+                if (keySymbol && v.value.type === ast_spec_1.AST_NODE_TYPES.Literal) {
+                    checkLiteral(keySymbol, v.value, true);
+                }
+                else if (v.value.type === ast_spec_1.AST_NODE_TYPES.ObjectExpression) {
+                    checkObjectExpression((0, type_1.getTSTypeByNode)(context, v.value).getNonNullableType().getProperties(), v.value.properties);
+                }
+            }
+        };
+        (0, type_1.useTypeChecker)(context);
+        return {
+            'CallExpression, NewExpression': function (node) {
+                var parameters = (0, type_1.getFunctionParameters)(context, node);
+                if (!parameters) {
+                    return;
+                }
+                var parameterIndex = 0;
+                for (var i = 0; i < node.arguments.length; i++) {
+                    var parameter = parameters[parameterIndex];
+                    if (!parameter)
+                        break;
+                    var argument = node.arguments[i];
+                    var isRest = (0, type_1.isRestParameter)(context, parameter);
+                    switch (argument.type) {
+                        case ast_spec_1.AST_NODE_TYPES.Literal:
+                            if (!parameterIndex && isCallingEventMethod(node)) {
+                                assertStringLiteral(argument, 'key', 'from-event');
+                            }
+                            else {
+                                checkLiteral(parameter, argument, false, isRest);
+                            }
+                            break;
+                        case ast_spec_1.AST_NODE_TYPES.ConditionalExpression:
+                            for (var _i = 0, _a = [argument.consequent, argument.alternate]; _i < _a.length; _i++) {
+                                var w = _a[_i];
+                                if (w.type !== ast_spec_1.AST_NODE_TYPES.Literal)
+                                    continue;
+                                checkLiteral(parameter, w);
+                            }
+                            break;
+                        case ast_spec_1.AST_NODE_TYPES.ObjectExpression:
+                            checkObjectExpression((0, type_1.getTSTypeBySymbol)(context, parameter, node).getProperties(), argument.properties);
+                            break;
+                    }
+                    if (!isRest) {
+                        parameterIndex++;
+                    }
+                }
+            },
+            MemberExpression: function (node) {
+                assertStringLiteral(node.property, 'key', 'from-keyish-usage');
+            },
+            ObjectExpression: function (node) {
+                var _a;
+                switch ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) {
+                    case ast_spec_1.AST_NODE_TYPES.VariableDeclarator:
+                        checkObjectExpression((0, type_1.getObjectProperties)(context, node.parent.id), node.properties);
+                        break;
+                    case ast_spec_1.AST_NODE_TYPES.TSAsExpression:
+                        checkObjectExpression((0, type_1.getObjectProperties)(context, node.parent.typeAnnotation), node.properties);
+                        break;
+                }
+            },
+            TSLiteralType: function (node) {
+                var _a;
+                if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) === ast_spec_1.AST_NODE_TYPES.TSIndexedAccessType) {
+                    assertStringLiteral(node.literal, 'key', 'from-keyish-name');
+                    return;
+                }
+                var fromGeneric = false;
+                v: for (var _i = 0, _b = context.getAncestors().reverse(); _i < _b.length; _i++) {
+                    var v = _b[_i];
+                    switch (v.type) {
+                        case ast_spec_1.AST_NODE_TYPES.TSPropertySignature:
+                            fromGeneric = false;
+                            break v;
+                        case ast_spec_1.AST_NODE_TYPES.TSTypeParameter:
+                        case ast_spec_1.AST_NODE_TYPES.TSTypeParameterInstantiation:
+                            fromGeneric = true;
+                            break v;
+                    }
+                }
+                if (fromGeneric) {
+                    assertStringLiteral(node.literal, 'key', 'from-generic');
+                }
+                else {
+                    assertStringLiteral(node.literal, 'value', 'from-valueish-usage');
+                }
+            },
+            TSPropertySignature: function (node) {
+                assertStringLiteral(node.key, 'key', 'from-keyish-usage');
+            }
+        };
+    }
+});
+function isCallingEventMethod(node) {
+    if (node.type !== ast_spec_1.AST_NODE_TYPES.CallExpression)
+        return false;
+    if (node.callee.type !== ast_spec_1.AST_NODE_TYPES.MemberExpression)
+        return false;
+    if (node.callee.property.type !== ast_spec_1.AST_NODE_TYPES.Identifier)
+        return false;
+    return eventMethodNames.includes(node.callee.property.name);
+}