eslint-plugin-formatjs 2.17.7

package/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2021 FormatJS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# eslint-plugin-formatjs
+
+We've migrated the docs to https://formatjs.io/docs/tooling/linter.

package/index.d.ts

@@ -0,0 +1,20 @@
+declare const plugin: {
+    rules: {
+        'blacklist-elements': import("eslint").Rule.RuleModule;
+        'enforce-default-message': import("eslint").Rule.RuleModule;
+        'enforce-description': import("eslint").Rule.RuleModule;
+        'enforce-id': import("eslint").Rule.RuleModule;
+        'enforce-placeholders': import("eslint").Rule.RuleModule;
+        'enforce-plural-rules': import("eslint").Rule.RuleModule;
+        'no-camel-case': import("eslint").Rule.RuleModule;
+        'no-complex-selectors': import("eslint").Rule.RuleModule;
+        'no-emoji': import("eslint").Rule.RuleModule;
+        'no-id': import("eslint").Rule.RuleModule;
+        'no-multiple-plurals': import("eslint").Rule.RuleModule;
+        'no-multiple-whitespaces': import("eslint").Rule.RuleModule;
+        'no-offset': import("eslint").Rule.RuleModule;
+    };
+};
+export declare type Plugin = typeof plugin;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin-formatjs/index.ts"],"names":[],"mappings":"AAaA,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;CAgBX,CAAA;AAED,oBAAY,MAAM,GAAG,OAAO,MAAM,CAAA"}

package/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var blacklist_elements_1 = tslib_1.__importDefault(require("./rules/blacklist-elements"));
+var enforce_default_message_1 = tslib_1.__importDefault(require("./rules/enforce-default-message"));
+var enforce_description_1 = tslib_1.__importDefault(require("./rules/enforce-description"));
+var enforce_id_1 = tslib_1.__importDefault(require("./rules/enforce-id"));
+var enforce_placeholders_1 = tslib_1.__importDefault(require("./rules/enforce-placeholders"));
+var enforce_plural_rules_1 = tslib_1.__importDefault(require("./rules/enforce-plural-rules"));
+var no_camel_case_1 = tslib_1.__importDefault(require("./rules/no-camel-case"));
+var no_complex_selectors_1 = tslib_1.__importDefault(require("./rules/no-complex-selectors"));
+var no_emoji_1 = tslib_1.__importDefault(require("./rules/no-emoji"));
+var no_id_1 = tslib_1.__importDefault(require("./rules/no-id"));
+var no_multiple_plurals_1 = tslib_1.__importDefault(require("./rules/no-multiple-plurals"));
+var no_multiple_whitespaces_1 = tslib_1.__importDefault(require("./rules/no-multiple-whitespaces"));
+var no_offset_1 = tslib_1.__importDefault(require("./rules/no-offset"));
+var plugin = {
+    rules: {
+        'blacklist-elements': blacklist_elements_1.default,
+        'enforce-default-message': enforce_default_message_1.default,
+        'enforce-description': enforce_description_1.default,
+        'enforce-id': enforce_id_1.default,
+        'enforce-placeholders': enforce_placeholders_1.default,
+        'enforce-plural-rules': enforce_plural_rules_1.default,
+        'no-camel-case': no_camel_case_1.default,
+        'no-complex-selectors': no_complex_selectors_1.default,
+        'no-emoji': no_emoji_1.default,
+        'no-id': no_id_1.default,
+        'no-multiple-plurals': no_multiple_plurals_1.default,
+        'no-multiple-whitespaces': no_multiple_whitespaces_1.default,
+        'no-offset': no_offset_1.default,
+    },
+};
+module.exports = plugin;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "eslint-plugin-formatjs",
+  "version": "2.17.7",
+  "description": "ESLint plugin for formatjs",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/formatjs/formatjs.git"
+  },
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "i18n",
+    "formatjs"
+  ],
+  "author": "Long Ho <holevietlong@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/formatjs/formatjs/issues"
+  },
+  "homepage": "https://github.com/formatjs/formatjs#readme",
+  "dependencies": {
+    "@formatjs/icu-messageformat-parser": "2.0.11",
+    "@formatjs/ts-transformer": "3.4.10",
+    "@types/eslint": "^7.2.0",
+    "@typescript-eslint/typescript-estree": "^4.11.0",
+    "emoji-regex": "^9.2.0",
+    "tslib": "^2.1.0",
+    "typescript": "4"
+  },
+  "peerDependencies": {
+    "eslint": "^7.4.0"
+  }
+}

package/rules/blacklist-elements.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=blacklist-elements.d.ts.map

package/rules/blacklist-elements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blacklist-elements.d.ts","sourceRoot":"","sources":["../../../../../../packages/eslint-plugin-formatjs/rules/blacklist-elements.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAkH3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UAyChB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/blacklist-elements.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var util_1 = require("../util");
+var icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+var BlacklistElement = /** @class */ (function (_super) {
+    tslib_1.__extends(BlacklistElement, _super);
+    function BlacklistElement(type) {
+        var _this = _super.call(this) || this;
+        _this.message = type + " element is blacklisted";
+        return _this;
+    }
+    return BlacklistElement;
+}(Error));
+var Element;
+(function (Element) {
+    Element["literal"] = "literal";
+    Element["argument"] = "argument";
+    Element["number"] = "number";
+    Element["date"] = "date";
+    Element["time"] = "time";
+    Element["select"] = "select";
+    Element["selectordinal"] = "selectordinal";
+    Element["plural"] = "plural";
+    Element["tag"] = "tag";
+})(Element || (Element = {}));
+function verifyAst(blacklist, ast) {
+    for (var _i = 0, ast_1 = ast; _i < ast_1.length; _i++) {
+        var el = ast_1[_i];
+        if (icu_messageformat_parser_1.isLiteralElement(el) && blacklist.includes(Element.literal)) {
+            throw new BlacklistElement(Element.literal);
+        }
+        if (icu_messageformat_parser_1.isArgumentElement(el) && blacklist.includes(Element.argument)) {
+            throw new BlacklistElement(Element.argument);
+        }
+        if (icu_messageformat_parser_1.isNumberElement(el) && blacklist.includes(Element.number)) {
+            throw new BlacklistElement(Element.number);
+        }
+        if (icu_messageformat_parser_1.isDateElement(el) && blacklist.includes(Element.date)) {
+            throw new BlacklistElement(Element.date);
+        }
+        if (icu_messageformat_parser_1.isTimeElement(el) && blacklist.includes(Element.time)) {
+            throw new BlacklistElement(Element.time);
+        }
+        if (icu_messageformat_parser_1.isSelectElement(el) && blacklist.includes(Element.select)) {
+            throw new BlacklistElement(Element.select);
+        }
+        if (icu_messageformat_parser_1.isTagElement(el) && blacklist.includes(Element.tag)) {
+            throw new BlacklistElement(Element.tag);
+        }
+        if (icu_messageformat_parser_1.isPluralElement(el)) {
+            if (blacklist.includes(Element.plural)) {
+                throw new BlacklistElement(Element.argument);
+            }
+            if (el.pluralType === 'ordinal' &&
+                blacklist.includes(Element.selectordinal)) {
+                throw new BlacklistElement(Element.selectordinal);
+            }
+        }
+        if (icu_messageformat_parser_1.isSelectElement(el) || icu_messageformat_parser_1.isPluralElement(el)) {
+            var options = el.options;
+            for (var _a = 0, _b = Object.keys(options); _a < _b.length; _a++) {
+                var selector = _b[_a];
+                verifyAst(blacklist, options[selector].value);
+            }
+        }
+    }
+}
+function checkNode(context, node) {
+    var msgs = util_1.extractMessages(node, context.settings);
+    if (!msgs.length) {
+        return;
+    }
+    var blacklist = context.options[0];
+    if (!Array.isArray(blacklist) || !blacklist.length) {
+        return;
+    }
+    for (var _i = 0, msgs_1 = msgs; _i < msgs_1.length; _i++) {
+        var _a = msgs_1[_i][0], defaultMessage = _a.message.defaultMessage, messageNode = _a.messageNode;
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        try {
+            verifyAst(context.options[0], icu_messageformat_parser_1.parse(defaultMessage, {
+                ignoreTag: context.settings.ignoreTag,
+            }));
+        }
+        catch (e) {
+            context.report({
+                node: messageNode,
+                message: e.message,
+            });
+        }
+    }
+}
+var rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow specific elements in ICU message format',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#blacklist-elements',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'array',
+                properties: {
+                    items: {
+                        type: 'string',
+                        enum: Object.keys(Element),
+                    },
+                },
+            },
+        ],
+    },
+    create: function (context) {
+        var callExpressionVisitor = function (node) {
+            return checkNode(context, node);
+        };
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: function (node) { return checkNode(context, node); },
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};
+exports.default = rule;

package/rules/enforce-default-message.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=enforce-default-message.d.ts.map

package/rules/enforce-default-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforce-default-message.d.ts","sourceRoot":"","sources":["../../../../../../packages/eslint-plugin-formatjs/rules/enforce-default-message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAiC3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UAmChB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/enforce-default-message.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../util");
+function checkNode(context, node) {
+    var msgs = util_1.extractMessages(node, context.settings);
+    var type = context.options[0];
+    for (var _i = 0, msgs_1 = msgs; _i < msgs_1.length; _i++) {
+        var _a = msgs_1[_i][0], defaultMessage = _a.message.defaultMessage, messageNode = _a.messageNode;
+        if (!defaultMessage) {
+            if (type === 'literal' && messageNode) {
+                context.report({
+                    node: messageNode,
+                    message: "\"defaultMessage\" must be:\n- a string literal or\n- template literal without variable",
+                });
+            }
+            else if (!messageNode) {
+                context.report({
+                    node: node,
+                    message: '`defaultMessage` has to be specified in message descriptor',
+                });
+            }
+        }
+    }
+}
+var rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce defaultMessage in message descriptor',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#enforce-default-message',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                enum: ['literal', 'anything'],
+            },
+        ],
+    },
+    create: function (context) {
+        var callExpressionVisitor = function (node) {
+            return checkNode(context, node);
+        };
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: function (node) { return checkNode(context, node); },
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};
+exports.default = rule;

package/rules/enforce-description.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+declare const _default: Rule.RuleModule;
+export default _default;
+//# sourceMappingURL=enforce-description.d.ts.map

package/rules/enforce-description.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforce-description.d.ts","sourceRoot":"","sources":["../../../../../../packages/eslint-plugin-formatjs/rules/enforce-description.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;;AAgC3B,wBAmCoB"}

package/rules/enforce-description.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../util");
+function checkNode(context, node) {
+    var msgs = util_1.extractMessages(node, context.settings);
+    var type = context.options[0];
+    for (var _i = 0, msgs_1 = msgs; _i < msgs_1.length; _i++) {
+        var _a = msgs_1[_i][0], description = _a.message.description, descriptionNode = _a.descriptionNode;
+        if (!description) {
+            if (type === 'literal' && descriptionNode) {
+                context.report({
+                    node: descriptionNode,
+                    message: '`description` has to be a string literal (not function call or variable)',
+                });
+            }
+            else if (!descriptionNode) {
+                context.report({
+                    node: node,
+                    message: '`description` has to be specified in message descriptor',
+                });
+            }
+        }
+    }
+}
+exports.default = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce description in message descriptor',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#enforce-description',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                enum: ['literal', 'anything'],
+            },
+        ],
+    },
+    create: function (context) {
+        var callExpressionVisitor = function (node) {
+            return checkNode(context, node);
+        };
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: function (node) { return checkNode(context, node); },
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};

package/rules/enforce-id.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+declare const _default: Rule.RuleModule;
+export default _default;
+//# sourceMappingURL=enforce-id.d.ts.map

package/rules/enforce-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforce-id.d.ts","sourceRoot":"","sources":["../../../../../../packages/eslint-plugin-formatjs/rules/enforce-id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;;AAoF3B,wBA0CoB"}

package/rules/enforce-id.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../util");
+var ts_transformer_1 = require("@formatjs/ts-transformer");
+function checkNode(context, node) {
+    var msgs = util_1.extractMessages(node, context.settings);
+    var options = context.options;
+    var _a = options[0], opt = _a === void 0 ? {} : _a;
+    var idInterpolationPattern = opt.idInterpolationPattern;
+    var _loop_1 = function (defaultMessage, description, id, idPropNode, descriptionNode, messagePropNode) {
+        if (!idInterpolationPattern && !idPropNode) {
+            context.report({
+                node: node,
+                message: "id must be specified",
+            });
+        }
+        else if (idInterpolationPattern) {
+            if (!defaultMessage) {
+                context.report({
+                    node: node,
+                    message: "defaultMessage must be a string literal to calculate generated IDs",
+                });
+            }
+            else if (!description && descriptionNode) {
+                context.report({
+                    node: node,
+                    message: "description must be a string literal to calculate generated IDs",
+                });
+            }
+            else {
+                var correctId_1 = ts_transformer_1.interpolateName({
+                    resourcePath: context.getFilename(),
+                }, idInterpolationPattern, {
+                    content: description
+                        ? defaultMessage + "#" + description
+                        : defaultMessage,
+                });
+                if (id !== correctId_1) {
+                    context.report({
+                        node: node,
+                        message: "\"id\" does not match with hash pattern " + idInterpolationPattern + ".\nExpected: " + correctId_1 + "\nActual: " + id,
+                        fix: function (fixer) {
+                            if (idPropNode) {
+                                if (idPropNode.type === 'JSXAttribute') {
+                                    return fixer.replaceText(idPropNode, "id=\"" + correctId_1 + "\"");
+                                }
+                                return fixer.replaceText(idPropNode, "id: '" + correctId_1 + "'");
+                            }
+                            // Insert after default message node
+                            if (messagePropNode.type === 'JSXAttribute') {
+                                return fixer.insertTextAfter(messagePropNode, " id=\"" + correctId_1 + "\"");
+                            }
+                            return fixer.replaceText(messagePropNode, "defaultMessage: '" + defaultMessage + "', id: '" + correctId_1 + "'");
+                        },
+                    });
+                }
+            }
+        }
+    };
+    for (var _i = 0, msgs_1 = msgs; _i < msgs_1.length; _i++) {
+        var _b = msgs_1[_i][0], _c = _b.message, defaultMessage = _c.defaultMessage, description = _c.description, id = _c.id, idPropNode = _b.idPropNode, descriptionNode = _b.descriptionNode, messagePropNode = _b.messagePropNode;
+        _loop_1(defaultMessage, description, id, idPropNode, descriptionNode, messagePropNode);
+    }
+}
+exports.default = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce (generated) ID in message descriptor',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#enforce-id',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    idInterpolationPattern: {
+                        type: 'string',
+                    },
+                },
+                required: ['idInterpolationPattern'],
+                additionalProperties: false,
+            },
+        ],
+    },
+    create: function (context) {
+        var callExpressionVisitor = function (node) {
+            return checkNode(context, node);
+        };
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: function (node) { return checkNode(context, node); },
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};

package/rules/enforce-placeholders.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=enforce-placeholders.d.ts.map

package/rules/enforce-placeholders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforce-placeholders.d.ts","sourceRoot":"","sources":["../../../../../../packages/eslint-plugin-formatjs/rules/enforce-placeholders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AA2G3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA6ChB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/enforce-placeholders.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var util_1 = require("../util");
+var icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+var PlaceholderEnforcement = /** @class */ (function (_super) {
+    tslib_1.__extends(PlaceholderEnforcement, _super);
+    function PlaceholderEnforcement(message) {
+        var _this = _super.call(this) || this;
+        _this.message = message;
+        return _this;
+    }
+    return PlaceholderEnforcement;
+}(Error));
+function keyExistsInExpression(key, values) {
+    if (!values) {
+        return false;
+    }
+    if (values.type !== 'ObjectExpression') {
+        return true; // True bc we cannot evaluate this
+    }
+    if (values.properties.find(function (prop) { return prop.type === 'SpreadElement'; })) {
+        return true; // True bc there's a spread element
+    }
+    return !!values.properties.find(function (prop) {
+        if (prop.type !== 'Property') {
+            return false;
+        }
+        switch (prop.key.type) {
+            case 'Identifier':
+                return prop.key.name === key;
+            case 'Literal':
+                return prop.key.value === key;
+        }
+        return false;
+    });
+}
+function verifyAst(ast, values, ignoreList) {
+    for (var _i = 0, ast_1 = ast; _i < ast_1.length; _i++) {
+        var el = ast_1[_i];
+        if (icu_messageformat_parser_1.isLiteralElement(el) || icu_messageformat_parser_1.isPoundElement(el)) {
+            continue;
+        }
+        var key = el.value;
+        if (!ignoreList.has(key) && !keyExistsInExpression(key, values)) {
+            throw new PlaceholderEnforcement("Missing value for placeholder \"" + el.value + "\"");
+        }
+        if (icu_messageformat_parser_1.isPluralElement(el) || icu_messageformat_parser_1.isSelectElement(el)) {
+            for (var _a = 0, _b = Object.keys(el.options); _a < _b.length; _a++) {
+                var selector = _b[_a];
+                verifyAst(el.options[selector].value, values, ignoreList);
+            }
+        }
+    }
+}
+function checkNode(context, node) {
+    var msgs = util_1.extractMessages(node, tslib_1.__assign({ excludeMessageDeclCalls: true }, context.settings));
+    var opt = context.options[0];
+    var ignoreList = new Set((opt === null || opt === void 0 ? void 0 : opt.ignoreList) || []);
+    for (var _i = 0, msgs_1 = msgs; _i < msgs_1.length; _i++) {
+        var _a = msgs_1[_i], _b = _a[0], defaultMessage = _b.message.defaultMessage, messageNode = _b.messageNode, values = _a[1];
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        try {
+            verifyAst(icu_messageformat_parser_1.parse(defaultMessage, {
+                ignoreTag: context.settings.ignoreTag,
+            }), values, ignoreList);
+        }
+        catch (e) {
+            context.report({
+                node: messageNode,
+                message: e.message,
+            });
+        }
+    }
+}
+var rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that all messages with placeholders have enough passed-in values',
+            category: 'Errors',
+            recommended: true,
+            url: 'https://formatjs.io/docs/tooling/linter#enforce-placeholders',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    ignoreList: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    create: function (context) {
+        var callExpressionVisitor = function (node) {
+            return checkNode(context, node);
+        };
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: function (node) { return checkNode(context, node); },
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};
+exports.default = rule;

package/rules/enforce-plural-rules.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=enforce-plural-rules.d.ts.map

package/rules/enforce-plural-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforce-plural-rules.d.ts","sourceRoot":"","sources":["../../../../../../packages/eslint-plugin-formatjs/rules/enforce-plural-rules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAoF3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA8ChB,CAAA;AAED,eAAe,IAAI,CAAA"}