eslint-plugin-formatjs 4.2.0 → 4.2.2

package/index.d.ts

@@ -0,0 +1,22 @@
+declare const plugin: {
+    rules: {
+        'blocklist-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-literal-string-in-jsx': import("eslint").Rule.RuleModule;
+        'no-multiple-plurals': import("eslint").Rule.RuleModule;
+        'no-multiple-whitespaces': import("eslint").Rule.RuleModule;
+        'no-invalid-icu': 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":["index.ts"],"names":[],"mappings":"AAeA,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;CAkBX,CAAA;AAED,oBAAY,MAAM,GAAG,OAAO,MAAM,CAAA"}

package/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const blocklist_elements_1 = tslib_1.__importDefault(require("./rules/blocklist-elements"));
+const enforce_default_message_1 = tslib_1.__importDefault(require("./rules/enforce-default-message"));
+const enforce_description_1 = tslib_1.__importDefault(require("./rules/enforce-description"));
+const enforce_id_1 = tslib_1.__importDefault(require("./rules/enforce-id"));
+const enforce_placeholders_1 = tslib_1.__importDefault(require("./rules/enforce-placeholders"));
+const no_invalid_icu_1 = tslib_1.__importDefault(require("./rules/no-invalid-icu"));
+const enforce_plural_rules_1 = tslib_1.__importDefault(require("./rules/enforce-plural-rules"));
+const no_camel_case_1 = tslib_1.__importDefault(require("./rules/no-camel-case"));
+const no_complex_selectors_1 = tslib_1.__importDefault(require("./rules/no-complex-selectors"));
+const no_emoji_1 = tslib_1.__importDefault(require("./rules/no-emoji"));
+const no_id_1 = tslib_1.__importDefault(require("./rules/no-id"));
+const no_multiple_plurals_1 = tslib_1.__importDefault(require("./rules/no-multiple-plurals"));
+const no_multiple_whitespaces_1 = tslib_1.__importDefault(require("./rules/no-multiple-whitespaces"));
+const no_offset_1 = tslib_1.__importDefault(require("./rules/no-offset"));
+const no_literal_string_in_jsx_1 = tslib_1.__importDefault(require("./rules/no-literal-string-in-jsx"));
+const plugin = {
+    rules: {
+        'blocklist-elements': blocklist_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-literal-string-in-jsx': no_literal_string_in_jsx_1.default,
+        'no-multiple-plurals': no_multiple_plurals_1.default,
+        'no-multiple-whitespaces': no_multiple_whitespaces_1.default,
+        'no-invalid-icu': no_invalid_icu_1.default,
+        'no-offset': no_offset_1.default,
+    },
+};
+module.exports = plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-formatjs",
-  "version": "4.2.0",
+  "version": "4.2.2",
   "description": "ESLint plugin for formatjs",
   "main": "index.js",
   "repository": {
@@ -20,8 +20,8 @@
   },
   "homepage": "https://github.com/formatjs/formatjs#readme",
   "dependencies": {
-    "@formatjs/icu-messageformat-parser": "2.1.5",
-    "@formatjs/ts-transformer": "3.9.10",
+    "@formatjs/icu-messageformat-parser": "2.1.6",
+    "@formatjs/ts-transformer": "3.9.11",
     "@types/eslint": "7 || 8",
     "@types/picomatch": "^2.3.0",
     "@typescript-eslint/typescript-estree": "^5.9.1",

package/rules/blocklist-elements.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"blocklist-elements.d.ts","sourceRoot":"","sources":["blocklist-elements.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAmH3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UAyChB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/blocklist-elements.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+class BlacklistElement extends Error {
+    constructor(type) {
+        super();
+        this.message = `${type} element is blocklisted`;
+    }
+}
+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(blocklist, ast) {
+    for (const el of ast) {
+        if ((0, icu_messageformat_parser_1.isLiteralElement)(el) && blocklist.includes(Element.literal)) {
+            throw new BlacklistElement(Element.literal);
+        }
+        if ((0, icu_messageformat_parser_1.isArgumentElement)(el) && blocklist.includes(Element.argument)) {
+            throw new BlacklistElement(Element.argument);
+        }
+        if ((0, icu_messageformat_parser_1.isNumberElement)(el) && blocklist.includes(Element.number)) {
+            throw new BlacklistElement(Element.number);
+        }
+        if ((0, icu_messageformat_parser_1.isDateElement)(el) && blocklist.includes(Element.date)) {
+            throw new BlacklistElement(Element.date);
+        }
+        if ((0, icu_messageformat_parser_1.isTimeElement)(el) && blocklist.includes(Element.time)) {
+            throw new BlacklistElement(Element.time);
+        }
+        if ((0, icu_messageformat_parser_1.isSelectElement)(el) && blocklist.includes(Element.select)) {
+            throw new BlacklistElement(Element.select);
+        }
+        if ((0, icu_messageformat_parser_1.isTagElement)(el) && blocklist.includes(Element.tag)) {
+            throw new BlacklistElement(Element.tag);
+        }
+        if ((0, icu_messageformat_parser_1.isPluralElement)(el)) {
+            if (blocklist.includes(Element.plural)) {
+                throw new BlacklistElement(Element.argument);
+            }
+            if (el.pluralType === 'ordinal' &&
+                blocklist.includes(Element.selectordinal)) {
+                throw new BlacklistElement(Element.selectordinal);
+            }
+        }
+        if ((0, icu_messageformat_parser_1.isSelectElement)(el) || (0, icu_messageformat_parser_1.isPluralElement)(el)) {
+            const { options } = el;
+            for (const selector of Object.keys(options)) {
+                verifyAst(blocklist, options[selector].value);
+            }
+        }
+    }
+}
+function checkNode(context, node) {
+    const settings = (0, util_1.getSettings)(context);
+    const msgs = (0, util_1.extractMessages)(node, settings);
+    if (!msgs.length) {
+        return;
+    }
+    const blocklist = context.options[0];
+    if (!Array.isArray(blocklist) || !blocklist.length) {
+        return;
+    }
+    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        try {
+            verifyAst(context.options[0], (0, icu_messageformat_parser_1.parse)(defaultMessage, {
+                ignoreTag: settings.ignoreTag,
+            }));
+        }
+        catch (e) {
+            context.report({
+                node: messageNode,
+                message: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+}
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow specific elements in ICU message format',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#blocklist-elements',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'array',
+                properties: {
+                    items: {
+                        type: 'string',
+                        enum: Object.keys(Element),
+                    },
+                },
+            },
+        ],
+    },
+    create(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => 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":["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,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+function checkNode(context, node) {
+    const msgs = (0, util_1.extractMessages)(node, (0, util_1.getSettings)(context));
+    const { options: [type], } = context;
+    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
+        if (!defaultMessage) {
+            if (type === 'literal' && messageNode) {
+                context.report({
+                    node: messageNode,
+                    message: `"defaultMessage" must be:
+- a string literal or
+- template literal without variable`,
+                });
+            }
+            else if (!messageNode) {
+                context.report({
+                    node: node,
+                    message: '`defaultMessage` has to be specified in message descriptor',
+                });
+            }
+        }
+    }
+}
+const 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(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => 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":["enforce-description.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;;AAgC3B,wBAmCoB"}

package/rules/enforce-description.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+function checkNode(context, node) {
+    const msgs = (0, util_1.extractMessages)(node, (0, util_1.getSettings)(context));
+    const { options: [type], } = context;
+    for (const [{ message: { description }, descriptionNode, },] of msgs) {
+        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(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => 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":["enforce-id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;;AA0G3B,wBAgEoB"}

package/rules/enforce-id.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const ts_transformer_1 = require("@formatjs/ts-transformer");
+function checkNode(context, node, { idInterpolationPattern, idWhitelistRegexps }) {
+    const msgs = (0, util_1.extractMessages)(node, (0, util_1.getSettings)(context));
+    for (const [{ message: { defaultMessage, description, id }, idPropNode, descriptionNode, messagePropNode, },] of msgs) {
+        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 {
+                if (idWhitelistRegexps &&
+                    id &&
+                    idWhitelistRegexps.some((r) => r.test(id))) {
+                    // messageId is allowlisted so skip interpolation id check
+                    return;
+                }
+                const correctId = (0, ts_transformer_1.interpolateName)({
+                    resourcePath: context.getFilename(),
+                }, idInterpolationPattern, {
+                    content: description
+                        ? `${defaultMessage}#${description}`
+                        : defaultMessage,
+                });
+                if (id !== correctId) {
+                    let message = `"id" does not match with hash pattern ${idInterpolationPattern}`;
+                    if (idWhitelistRegexps) {
+                        message += ` or allowlisted patterns ["${idWhitelistRegexps
+                            .map(r => r.toString())
+                            .join('", "')}"]`;
+                    }
+                    context.report({
+                        node: node,
+                        message: `${message}.
+Expected: ${correctId}
+Actual: ${id}`,
+                        fix(fixer) {
+                            if (idPropNode) {
+                                if (idPropNode.type === 'JSXAttribute') {
+                                    return fixer.replaceText(idPropNode, `id="${correctId}"`);
+                                }
+                                return fixer.replaceText(idPropNode, `id: '${correctId}'`);
+                            }
+                            // Insert after default message node
+                            if (messagePropNode.type === 'JSXAttribute') {
+                                return fixer.insertTextAfter(messagePropNode, ` id="${correctId}"`);
+                            }
+                            return fixer.replaceText(messagePropNode, `defaultMessage: '${defaultMessage}', id: '${correctId}'`);
+                        },
+                    });
+                }
+            }
+        }
+    }
+}
+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',
+                        description: 'Pattern to verify ID against. Recommended value: [sha512:contenthash:base64:6]',
+                    },
+                    idWhitelist: {
+                        type: 'array',
+                        description: "An array of strings with regular expressions. This array allows allowlist custom ids for messages. For example '`\\\\.`' allows any id which has dot; `'^payment_.*'` - allows any custom id which has prefix `payment_`. Be aware that any backslash \\ provided via string must be escaped with an additional backslash.",
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+                required: ['idInterpolationPattern'],
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        const tmp = context?.options?.[0];
+        const opts = {
+            idInterpolationPattern: tmp?.idInterpolationPattern,
+        };
+        if (Array.isArray(tmp?.idWhitelist)) {
+            const { idWhitelist } = tmp;
+            opts.idWhitelistRegexps = idWhitelist.map((str) => new RegExp(str, 'i'));
+        }
+        const callExpressionVisitor = (node) => checkNode(context, node, opts);
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => checkNode(context, node, opts),
+            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":["enforce-placeholders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAiH3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA6ChB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/enforce-placeholders.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+class PlaceholderEnforcement extends Error {
+    constructor(message) {
+        super();
+        this.message = message;
+    }
+}
+function keyExistsInExpression(key, values) {
+    if (!values) {
+        return false;
+    }
+    if (values.type !== 'ObjectExpression') {
+        return true; // True bc we cannot evaluate this
+    }
+    if (values.properties.find(prop => prop.type === 'SpreadElement')) {
+        return true; // True bc there's a spread element
+    }
+    return !!values.properties.find(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 (const el of ast) {
+        if ((0, icu_messageformat_parser_1.isLiteralElement)(el) || (0, icu_messageformat_parser_1.isPoundElement)(el)) {
+            continue;
+        }
+        const key = el.value;
+        if (!ignoreList.has(key) && !keyExistsInExpression(key, values)) {
+            throw new PlaceholderEnforcement(`Missing value for placeholder "${el.value}"`);
+        }
+        if ((0, icu_messageformat_parser_1.isPluralElement)(el) || (0, icu_messageformat_parser_1.isSelectElement)(el)) {
+            for (const selector of Object.keys(el.options)) {
+                verifyAst(el.options[selector].value, values, ignoreList);
+            }
+        }
+        if ((0, icu_messageformat_parser_1.isTagElement)(el)) {
+            verifyAst(el.children, values, ignoreList);
+        }
+    }
+}
+function checkNode(context, node) {
+    const settings = (0, util_1.getSettings)(context);
+    const msgs = (0, util_1.extractMessages)(node, {
+        excludeMessageDeclCalls: true,
+        ...settings,
+    });
+    const { options: [opt], } = context;
+    const ignoreList = new Set(opt?.ignoreList || []);
+    for (const [{ message: { defaultMessage }, messageNode, }, values,] of msgs) {
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        try {
+            verifyAst((0, icu_messageformat_parser_1.parse)(defaultMessage, {
+                ignoreTag: settings.ignoreTag,
+            }), values, ignoreList);
+        }
+        catch (e) {
+            context.report({
+                node: messageNode,
+                message: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+}
+const 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(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => 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":["enforce-plural-rules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAqF3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA8ChB,CAAA;AAED,eAAe,IAAI,CAAA"}