eslint-plugin-formatjs 5.2.5 → 5.2.6

package/lib_esnext/context-compat.d.ts

@@ -0,0 +1,2 @@
+import { RuleContext } from '@typescript-eslint/utils/ts-eslint';
+export declare const getParserServices: <TRuleContext extends RuleContext<string, unknown[]>>(context: TRuleContext) => Partial<import("@typescript-eslint/utils").ParserServicesWithTypeInformation> | Partial<import("@typescript-eslint/utils").ParserServicesWithoutTypeInformation> | undefined;

package/lib_esnext/context-compat.js

@@ -0,0 +1,6 @@
+export const getParserServices = (context) => {
+    if (context.parserServices) {
+        return context.parserServices;
+    }
+    return context.sourceCode.parserServices;
+};

package/lib_esnext/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib_esnext/index.js

@@ -0,0 +1,143 @@
+import { name as blocklistElementRuleName, rule as blocklistElements, } from './rules/blocklist-elements';
+import { rule as enforceDefaultMessage, name as enforceDefaultMessageName, } from './rules/enforce-default-message';
+import { rule as enforceDescription, name as enforceDescriptionName, } from './rules/enforce-description';
+import { rule as enforceId, name as enforceIdName } from './rules/enforce-id';
+import { rule as enforcePlaceholders, name as enforcePlaceholdersName, } from './rules/enforce-placeholders';
+import { rule as enforcePluralRules, name as enforcePluralRulesName, } from './rules/enforce-plural-rules';
+import { rule as noCamelCase, name as noCamelCaseName, } from './rules/no-camel-case';
+import { rule as noComplexSelectors, name as noComplexSelectorsName, } from './rules/no-complex-selectors';
+import { rule as noEmoji, name as noEmojiName } from './rules/no-emoji';
+import { rule as noId, name as noIdName } from './rules/no-id';
+import { rule as noInvalidICU, name as noInvalidICUName, } from './rules/no-invalid-icu';
+import { rule as noLiteralStringInJsx, name as noLiteralStringInJsxName, } from './rules/no-literal-string-in-jsx';
+import { rule as noMissingIcuPluralOnePlaceholders, name as noMissingIcuPluralOnePlaceholdersName, } from './rules/no-missing-icu-plural-one-placeholders';
+import { rule as noMultiplePlurals, name as noMultiplePluralsName, } from './rules/no-multiple-plurals';
+import { rule as noMultipleWhitespaces, name as noMultipleWhitespacesName, } from './rules/no-multiple-whitespaces';
+import { rule as noOffset, name as noOffsetName } from './rules/no-offset';
+import { rule as noUselessMessage, name as noUselessMessageName, } from './rules/no-useless-message';
+import { rule as preferFormattedMessage, name as preferFormattedMessageName, } from './rules/prefer-formatted-message';
+import { rule as preferPoundInPlural, name as preferPoundInPluralName, } from './rules/prefer-pound-in-plural';
+import { name, version } from './package.json';
+// All rules
+const rules = {
+    // @ts-expect-error
+    [blocklistElementRuleName]: blocklistElements,
+    // @ts-expect-error
+    [enforceDefaultMessageName]: enforceDefaultMessage,
+    // @ts-expect-error
+    [enforceDescriptionName]: enforceDescription,
+    // @ts-expect-error
+    [enforceIdName]: enforceId,
+    // @ts-expect-error
+    [enforcePlaceholdersName]: enforcePlaceholders,
+    // @ts-expect-error
+    [enforcePluralRulesName]: enforcePluralRules,
+    // @ts-expect-error
+    [noCamelCaseName]: noCamelCase,
+    // @ts-expect-error
+    [noComplexSelectorsName]: noComplexSelectors,
+    // @ts-expect-error
+    [noEmojiName]: noEmoji,
+    // @ts-expect-error
+    [noIdName]: noId,
+    // @ts-expect-error
+    [noInvalidICUName]: noInvalidICU,
+    // @ts-expect-error
+    [noLiteralStringInJsxName]: noLiteralStringInJsx,
+    // @ts-expect-error
+    [noMultiplePluralsName]: noMultiplePlurals,
+    // @ts-expect-error
+    [noMultipleWhitespacesName]: noMultipleWhitespaces,
+    // @ts-expect-error
+    [noOffsetName]: noOffset,
+    // @ts-expect-error
+    [noUselessMessageName]: noUselessMessage,
+    // @ts-expect-error
+    [preferFormattedMessageName]: preferFormattedMessage,
+    // @ts-expect-error
+    [preferPoundInPluralName]: preferPoundInPlural,
+    // @ts-expect-error
+    [noMissingIcuPluralOnePlaceholdersName]: noMissingIcuPluralOnePlaceholders,
+};
+// Base plugin
+const plugin = {
+    meta: { name, version },
+    rules,
+};
+// Configs
+const configs = {
+    strict: {
+        name: 'formatjs/strict',
+        plugins: { formatjs: plugin },
+        rules: {
+            'formatjs/no-offset': 'error',
+            'formatjs/enforce-default-message': ['error', 'literal'],
+            'formatjs/enforce-description': ['error', 'literal'],
+            'formatjs/enforce-placeholders': 'error',
+            'formatjs/no-emoji': 'error',
+            'formatjs/no-multiple-whitespaces': 'error',
+            'formatjs/no-multiple-plurals': 'error',
+            'formatjs/no-complex-selectors': ['error', { limit: 20 }],
+            'formatjs/no-useless-message': 'error',
+            'formatjs/prefer-pound-in-plural': 'error',
+            'formatjs/no-missing-icu-plural-one-placeholders': 'error',
+            'formatjs/enforce-id': [
+                'error',
+                {
+                    idInterpolationPattern: '[sha512:contenthash:base64:10]',
+                },
+            ],
+            'formatjs/enforce-plural-rules': [
+                'error',
+                {
+                    one: true,
+                    other: true,
+                },
+            ],
+            'formatjs/no-literal-string-in-jsx': [
+                'error',
+                {
+                    props: {
+                        include: [['*', '{label,placeholder,title}']],
+                    },
+                },
+            ],
+            'formatjs/blocklist-elements': ['error', ['selectordinal']],
+        },
+    },
+    recommended: {
+        name: 'formatjs/recommended',
+        plugins: { formatjs: plugin },
+        rules: {
+            'formatjs/no-offset': 'error',
+            'formatjs/enforce-default-message': ['error', 'literal'],
+            'formatjs/enforce-description': ['error', 'literal'],
+            'formatjs/enforce-placeholders': 'error',
+            'formatjs/no-emoji': 'error',
+            'formatjs/no-multiple-whitespaces': 'error',
+            'formatjs/no-multiple-plurals': 'error',
+            'formatjs/no-complex-selectors': ['error', { limit: 20 }],
+            'formatjs/no-useless-message': 'error',
+            'formatjs/prefer-pound-in-plural': 'error',
+            'formatjs/no-missing-icu-plural-one-placeholders': 'error',
+            'formatjs/enforce-plural-rules': [
+                'error',
+                {
+                    one: true,
+                    other: true,
+                },
+            ],
+            'formatjs/no-literal-string-in-jsx': [
+                'warn',
+                {
+                    props: {
+                        include: [['*', '{label,placeholder,title}']],
+                    },
+                },
+            ],
+            'formatjs/blocklist-elements': ['error', ['selectordinal']],
+        },
+    },
+};
+plugin.configs = configs;
+module.exports = plugin;

package/lib_esnext/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "eslint-plugin-formatjs",
+    "version": "5.2.6",
+    "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": "workspace:*",
+        "@formatjs/ts-transformer": "workspace:*",
+        "@types/eslint": "9",
+        "@types/picomatch": "3",
+        "@typescript-eslint/utils": "8.17.0",
+        "emoji-regex": "10",
+        "magic-string": "^0.30.0",
+        "picomatch": "2 || 3 || 4",
+        "tslib": "2",
+        "unicode-emoji-utils": "^1.2.0"
+    },
+    "peerDependencies": {
+        "eslint": "9"
+    }
+}

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

@@ -0,0 +1,14 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const name = "blocklist-elements";
+export declare enum Element {
+    literal = "literal",
+    argument = "argument",
+    number = "number",
+    date = "date",
+    time = "time",
+    select = "select",
+    selectordinal = "selectordinal",
+    plural = "plural",
+    tag = "tag"
+}
+export declare const rule: ESLintUtils.RuleModule<"blocklist", [], unknown, ESLintUtils.RuleListener>;

package/lib_esnext/rules/blocklist-elements.js

@@ -0,0 +1,132 @@
+import { isArgumentElement, isDateElement, isLiteralElement, isNumberElement, isPluralElement, isSelectElement, isTagElement, isTimeElement, parse, } from '@formatjs/icu-messageformat-parser';
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getParserServices } from '../context-compat';
+import { extractMessages, getSettings } from '../util';
+export const name = 'blocklist-elements';
+function getMessage(type) {
+    return {
+        messageId: 'blocklist',
+        data: { type },
+    };
+}
+export 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) {
+    const errors = [];
+    for (const el of ast) {
+        if (isLiteralElement(el) && blocklist.includes(Element.literal)) {
+            errors.push(getMessage(Element.literal));
+        }
+        if (isArgumentElement(el) && blocklist.includes(Element.argument)) {
+            errors.push(getMessage(Element.argument));
+        }
+        if (isNumberElement(el) && blocklist.includes(Element.number)) {
+            errors.push(getMessage(Element.number));
+        }
+        if (isDateElement(el) && blocklist.includes(Element.date)) {
+            errors.push(getMessage(Element.date));
+        }
+        if (isTimeElement(el) && blocklist.includes(Element.time)) {
+            errors.push(getMessage(Element.time));
+        }
+        if (isSelectElement(el) && blocklist.includes(Element.select)) {
+            errors.push(getMessage(Element.select));
+        }
+        if (isTagElement(el) && blocklist.includes(Element.tag)) {
+            errors.push(getMessage(Element.tag));
+        }
+        if (isPluralElement(el)) {
+            if (blocklist.includes(Element.plural)) {
+                errors.push(getMessage(Element.argument));
+            }
+            if (el.pluralType === 'ordinal' &&
+                blocklist.includes(Element.selectordinal)) {
+                errors.push(getMessage(Element.selectordinal));
+            }
+        }
+        if (isSelectElement(el) || isPluralElement(el)) {
+            const { options } = el;
+            for (const selector of Object.keys(options)) {
+                verifyAst(blocklist, options[selector].value);
+            }
+        }
+    }
+    return errors;
+}
+function checkNode(context, node) {
+    const settings = getSettings(context);
+    const msgs = 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;
+        }
+        const errors = verifyAst(blocklist, parse(defaultMessage, {
+            ignoreTag: settings.ignoreTag,
+        }));
+        for (const error of errors) {
+            context.report({
+                node,
+                ...error,
+            });
+        }
+    }
+}
+const createRule = ESLintUtils.RuleCreator(_ => 'https://formatjs.github.io/docs/tooling/linter#blocklist-elements');
+export const rule = createRule({
+    name,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow specific elements in ICU message format',
+            url: 'https://formatjs.github.io/docs/tooling/linter#blocklist-elements',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: Object.keys(Element),
+                },
+            },
+        ],
+        messages: {
+            blocklist: `{{type}} element is blocklisted`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const callExpressionVisitor = node => checkNode(context, node);
+        const parserServices = getParserServices(context);
+        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+        if (parserServices?.defineTemplateBodyVisitor) {
+            //@ts-expect-error
+            return parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: node => checkNode(context, node),
+            CallExpression: callExpressionVisitor,
+        };
+    },
+});

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

@@ -0,0 +1,10 @@
+import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
+export declare enum Option {
+    literal = "literal",
+    anything = "anything"
+}
+type MessageIds = 'defaultMessage' | 'defaultMessageLiteral';
+type Options = [`${Option}`?];
+export declare const name = "enforce-default-message";
+export declare const rule: RuleModule<MessageIds, Options>;
+export {};

package/lib_esnext/rules/enforce-default-message.js

@@ -0,0 +1,68 @@
+import { getParserServices } from '../context-compat';
+import { extractMessages, getSettings } from '../util';
+export var Option;
+(function (Option) {
+    Option["literal"] = "literal";
+    Option["anything"] = "anything";
+})(Option || (Option = {}));
+export const name = 'enforce-default-message';
+function checkNode(context, node) {
+    const msgs = extractMessages(node, getSettings(context));
+    const { options: [type], } = context;
+    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
+        if (!defaultMessage) {
+            if (type === 'literal' && messageNode) {
+                context.report({
+                    node: messageNode,
+                    messageId: 'defaultMessageLiteral',
+                });
+            }
+            else if (!messageNode) {
+                context.report({
+                    node: node,
+                    messageId: 'defaultMessage',
+                });
+            }
+        }
+    }
+}
+export const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce defaultMessage in message descriptor',
+            url: 'https://formatjs.github.io/docs/tooling/linter#enforce-default-message',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'string',
+                enum: Object.keys(Option),
+            },
+        ],
+        messages: {
+            defaultMessageLiteral: `"defaultMessage" must be:
+- a string literal or
+- template literal without variable`,
+            defaultMessage: '`defaultMessage` has to be specified in message descriptor',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        const parserServices = getParserServices(context);
+        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+        if (parserServices?.defineTemplateBodyVisitor) {
+            //@ts-expect-error
+            return parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => checkNode(context, node),
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};

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

@@ -0,0 +1,10 @@
+import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
+export declare enum Option {
+    literal = "literal",
+    anything = "anything"
+}
+type MessageIds = 'enforceDescription' | 'enforceDescriptionLiteral';
+type Options = [`${Option}`?];
+export declare const name = "enforce-description";
+export declare const rule: RuleModule<MessageIds, Options>;
+export {};

package/lib_esnext/rules/enforce-description.js

@@ -0,0 +1,66 @@
+import { getParserServices } from '../context-compat';
+import { extractMessages, getSettings } from '../util';
+export var Option;
+(function (Option) {
+    Option["literal"] = "literal";
+    Option["anything"] = "anything";
+})(Option || (Option = {}));
+function checkNode(context, node) {
+    const msgs = extractMessages(node, getSettings(context));
+    const { options: [type], } = context;
+    for (const [{ message: { description }, descriptionNode, },] of msgs) {
+        if (!description) {
+            if (type === 'literal' && descriptionNode) {
+                context.report({
+                    node: descriptionNode,
+                    messageId: 'enforceDescriptionLiteral',
+                });
+            }
+            else if (!descriptionNode) {
+                context.report({
+                    node: node,
+                    messageId: 'enforceDescription',
+                });
+            }
+        }
+    }
+}
+export const name = 'enforce-description';
+export const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce description in message descriptor',
+            url: 'https://formatjs.github.io/docs/tooling/linter#enforce-description',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'string',
+                enum: Object.keys(Option),
+            },
+        ],
+        messages: {
+            enforceDescription: '`description` has to be specified in message descriptor',
+            enforceDescriptionLiteral: '`description` has to be a string literal (not function call or variable)',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        const parserServices = getParserServices(context);
+        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+        if (parserServices?.defineTemplateBodyVisitor) {
+            //@ts-expect-error
+            return parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => checkNode(context, node),
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};

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

@@ -0,0 +1,10 @@
+import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
+export type Option = {
+    idInterpolationPattern: string;
+    idWhitelist?: string[];
+};
+type MessageIds = 'enforceId' | 'enforceIdDefaultMessage' | 'enforceIdDescription' | 'enforceIdMatching' | 'enforceIdMatchingAllowlisted';
+type Options = [Option];
+export declare const name = "enforce-id";
+export declare const rule: RuleModule<MessageIds, Options>;
+export {};

package/lib_esnext/rules/enforce-id.js

@@ -0,0 +1,153 @@
+import { interpolateName } from '@formatjs/ts-transformer';
+import { getParserServices } from '../context-compat';
+import { extractMessages, getSettings } from '../util';
+function checkNode(context, node, { idInterpolationPattern, idWhitelistRegexps, }) {
+    const msgs = extractMessages(node, getSettings(context));
+    for (const [{ message: { defaultMessage, description, id }, idPropNode, descriptionNode, messagePropNode, },] of msgs) {
+        if (!idInterpolationPattern && !idPropNode) {
+            context.report({
+                node,
+                messageId: 'enforceId',
+            });
+        }
+        else if (idInterpolationPattern) {
+            if (!defaultMessage) {
+                context.report({
+                    node,
+                    messageId: 'enforceIdDefaultMessage',
+                });
+            }
+            else if (!description && descriptionNode) {
+                context.report({
+                    node,
+                    messageId: 'enforceIdDescription',
+                });
+            }
+            else {
+                if (idWhitelistRegexps &&
+                    id &&
+                    idWhitelistRegexps.some((r) => r.test(id))) {
+                    // messageId is allowlisted so skip interpolation id check
+                    continue;
+                }
+                const correctId = interpolateName({
+                    resourcePath: context.getFilename(),
+                }, idInterpolationPattern, {
+                    content: description
+                        ? `${defaultMessage}#${description}`
+                        : defaultMessage,
+                });
+                if (id !== correctId) {
+                    let messageId = 'enforceIdMatching';
+                    let messageData = {
+                        idInterpolationPattern,
+                        expected: correctId,
+                        actual: id,
+                    };
+                    if (idWhitelistRegexps) {
+                        messageId = 'enforceIdMatchingAllowlisted';
+                        messageData = {
+                            ...messageData,
+                            idWhitelist: idWhitelistRegexps
+                                .map(r => `"${r.toString()}"`)
+                                .join(', '),
+                        };
+                    }
+                    context.report({
+                        node,
+                        messageId,
+                        data: messageData,
+                        fix(fixer) {
+                            if (idPropNode) {
+                                if (idPropNode.type === 'JSXAttribute') {
+                                    return fixer.replaceText(idPropNode, `id="${correctId}"`);
+                                }
+                                return fixer.replaceText(idPropNode, `id: '${correctId}'`);
+                            }
+                            if (messagePropNode) {
+                                // Insert after default message node
+                                if (messagePropNode.type === 'JSXAttribute') {
+                                    return fixer.insertTextAfter(messagePropNode, ` id="${correctId}"`);
+                                }
+                                return fixer.insertTextAfter(messagePropNode, `, id: '${correctId}'`);
+                            }
+                            return null;
+                        },
+                    });
+                }
+            }
+        }
+    }
+}
+export const name = 'enforce-id';
+export const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce (generated) ID in message descriptor',
+            url: 'https://formatjs.github.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,
+            },
+        ],
+        messages: {
+            enforceId: `id must be specified`,
+            enforceIdDefaultMessage: `defaultMessage must be a string literal to calculate generated IDs`,
+            enforceIdDescription: `description must be a string literal to calculate generated IDs`,
+            enforceIdMatching: `"id" does not match with hash pattern {{idInterpolationPattern}}.
+Expected: {{expected}}
+Actual: {{actual}}`,
+            enforceIdMatchingAllowlisted: `"id" does not match with hash pattern {{idInterpolationPattern}} or allowlisted patterns {{idWhitelist}}.
+Expected: {{expected}}
+Actual: {{actual}}`,
+        },
+    },
+    defaultOptions: [
+        {
+            idInterpolationPattern: '[sha512:contenthash:base64:6]',
+        },
+    ],
+    create(context) {
+        const tmp = context.options[0];
+        let 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);
+        const parserServices = getParserServices(context);
+        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+        if (parserServices?.defineTemplateBodyVisitor) {
+            //@ts-expect-error
+            return parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => checkNode(context, node, opts),
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};

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

@@ -0,0 +1,8 @@
+import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
+type MessageIds = 'parserError' | 'missingValue' | 'unusedValue';
+type Options = [{
+    ignoreList: string[];
+}?];
+export declare const name = "enforce-placeholders";
+export declare const rule: RuleModule<MessageIds, Options>;
+export {};