@alexlit/lint-kit 167.3.0 → 167.4.0

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/index.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const base_1 = __importDefault(require("./configs/base"));
+const recommended_1 = __importDefault(require("./configs/recommended"));
+const base_2 = __importDefault(require("./configs/flat/base"));
+const recommended_2 = __importDefault(require("./configs/flat/recommended"));
+const key_format_style_1 = __importDefault(require("./rules/key-format-style"));
+const no_deprecated_i18n_component_1 = __importDefault(require("./rules/no-deprecated-i18n-component"));
+const no_deprecated_i18n_place_attr_1 = __importDefault(require("./rules/no-deprecated-i18n-place-attr"));
+const no_deprecated_i18n_places_prop_1 = __importDefault(require("./rules/no-deprecated-i18n-places-prop"));
+const no_deprecated_modulo_syntax_1 = __importDefault(require("./rules/no-deprecated-modulo-syntax"));
+const no_deprecated_tc_1 = __importDefault(require("./rules/no-deprecated-tc"));
+const no_deprecated_v_t_1 = __importDefault(require("./rules/no-deprecated-v-t"));
+const no_duplicate_keys_in_locale_1 = __importDefault(require("./rules/no-duplicate-keys-in-locale"));
+const no_dynamic_keys_1 = __importDefault(require("./rules/no-dynamic-keys"));
+const no_html_messages_1 = __importDefault(require("./rules/no-html-messages"));
+const no_i18n_t_path_prop_1 = __importDefault(require("./rules/no-i18n-t-path-prop"));
+const no_missing_keys_in_other_locales_1 = __importDefault(require("./rules/no-missing-keys-in-other-locales"));
+const no_missing_keys_1 = __importDefault(require("./rules/no-missing-keys"));
+const no_raw_text_1 = __importDefault(require("./rules/no-raw-text"));
+const no_unknown_locale_1 = __importDefault(require("./rules/no-unknown-locale"));
+const no_unused_keys_1 = __importDefault(require("./rules/no-unused-keys"));
+const no_v_html_1 = __importDefault(require("./rules/no-v-html"));
+const prefer_linked_key_with_paren_1 = __importDefault(require("./rules/prefer-linked-key-with-paren"));
+const prefer_sfc_lang_attr_1 = __importDefault(require("./rules/prefer-sfc-lang-attr"));
+const sfc_locale_attr_1 = __importDefault(require("./rules/sfc-locale-attr"));
+const valid_message_syntax_1 = __importDefault(require("./rules/valid-message-syntax"));
+module.exports = {
+    configs: {
+        'base-legacy': base_1.default,
+        'recommended-legacy': recommended_1.default,
+        base: base_2.default,
+        recommended: recommended_2.default,
+        'flat/base': base_2.default,
+        'flat/recommended': recommended_2.default
+    },
+    rules: {
+        'key-format-style': key_format_style_1.default,
+        'no-deprecated-i18n-component': no_deprecated_i18n_component_1.default,
+        'no-deprecated-i18n-place-attr': no_deprecated_i18n_place_attr_1.default,
+        'no-deprecated-i18n-places-prop': no_deprecated_i18n_places_prop_1.default,
+        'no-deprecated-modulo-syntax': no_deprecated_modulo_syntax_1.default,
+        'no-deprecated-tc': no_deprecated_tc_1.default,
+        'no-deprecated-v-t': no_deprecated_v_t_1.default,
+        'no-duplicate-keys-in-locale': no_duplicate_keys_in_locale_1.default,
+        'no-dynamic-keys': no_dynamic_keys_1.default,
+        'no-html-messages': no_html_messages_1.default,
+        'no-i18n-t-path-prop': no_i18n_t_path_prop_1.default,
+        'no-missing-keys-in-other-locales': no_missing_keys_in_other_locales_1.default,
+        'no-missing-keys': no_missing_keys_1.default,
+        'no-raw-text': no_raw_text_1.default,
+        'no-unknown-locale': no_unknown_locale_1.default,
+        'no-unused-keys': no_unused_keys_1.default,
+        'no-v-html': no_v_html_1.default,
+        'prefer-linked-key-with-paren': prefer_linked_key_with_paren_1.default,
+        'prefer-sfc-lang-attr': prefer_sfc_lang_attr_1.default,
+        'sfc-locale-attr': sfc_locale_attr_1.default,
+        'valid-message-syntax': valid_message_syntax_1.default
+    }
+};

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/key-format-style.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types").RuleModule;
+export = _default;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/key-format-style.js

@@ -0,0 +1,247 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const path_1 = require("path");
+const index_1 = require("../utils/index");
+const debug_1 = __importDefault(require("debug"));
+const casing_1 = require("../utils/casing");
+const rule_1 = require("../utils/rule");
+const compat_1 = require("../utils/compat");
+const debug = (0, debug_1.default)('eslint-plugin-vue-i18n:key-format-style');
+const allowedCaseOptions = [
+    'camelCase',
+    'kebab-case',
+    'lowercase',
+    'snake_case',
+    'SCREAMING_SNAKE_CASE'
+];
+function create(context) {
+    var _a, _b, _c;
+    const filename = (0, compat_1.getFilename)(context);
+    const sourceCode = (0, compat_1.getSourceCode)(context);
+    const expectCasing = (_a = context.options[0]) !== null && _a !== void 0 ? _a : 'camelCase';
+    const checker = (0, casing_1.getCasingChecker)(expectCasing);
+    const allowArray = (_b = context.options[1]) === null || _b === void 0 ? void 0 : _b.allowArray;
+    const splitByDotsOption = (_c = context.options[1]) === null || _c === void 0 ? void 0 : _c.splitByDots;
+    function reportUnknown(reportNode) {
+        context.report({
+            message: `Unexpected object key. Use ${expectCasing} string key instead`,
+            loc: reportNode.loc
+        });
+    }
+    function verifyKeyForString(key, reportNode) {
+        for (const target of splitByDotsOption && key.includes('.')
+            ? splitByDots(key, reportNode)
+            : [{ key, loc: reportNode.loc }]) {
+            if (!checker(target.key)) {
+                context.report({
+                    message: `"{{key}}" is not {{expectCasing}}`,
+                    loc: target.loc,
+                    data: {
+                        key: target.key,
+                        expectCasing
+                    }
+                });
+            }
+        }
+    }
+    function verifyKeyForNumber(key, reportNode) {
+        if (!allowArray) {
+            context.report({
+                message: `Unexpected array element`,
+                loc: reportNode.loc
+            });
+        }
+    }
+    function splitByDots(key, reportNode) {
+        const result = [];
+        let startIndex = 0;
+        let index;
+        while ((index = key.indexOf('.', startIndex)) >= 0) {
+            const getLoc = buildGetLocation(startIndex, index);
+            result.push({
+                key: key.slice(startIndex, index),
+                get loc() {
+                    return getLoc();
+                }
+            });
+            startIndex = index + 1;
+        }
+        const getLoc = buildGetLocation(startIndex, key.length);
+        result.push({
+            key: key.slice(startIndex, index),
+            get loc() {
+                return getLoc();
+            }
+        });
+        return result;
+        function buildGetLocation(start, end) {
+            const offset = reportNode.type === 'JSONLiteral' ||
+                (reportNode.type === 'YAMLScalar' &&
+                    (reportNode.style === 'double-quoted' ||
+                        reportNode.style === 'single-quoted'))
+                ? reportNode.range[0] + 1
+                : reportNode.range[0];
+            let cachedLoc;
+            return () => {
+                if (cachedLoc) {
+                    return cachedLoc;
+                }
+                return (cachedLoc = {
+                    start: sourceCode.getLocFromIndex(offset + start),
+                    end: sourceCode.getLocFromIndex(offset + end)
+                });
+            };
+        }
+    }
+    function createVisitorForJson(targetLocaleMessage) {
+        let keyStack = {
+            inLocale: targetLocaleMessage.isResolvedLocaleByFileName()
+        };
+        return {
+            JSONProperty(node) {
+                const { inLocale } = keyStack;
+                keyStack = {
+                    node,
+                    inLocale: true,
+                    upper: keyStack
+                };
+                if (!inLocale) {
+                    return;
+                }
+                const key = node.key.type === 'JSONLiteral' ? `${node.key.value}` : node.key.name;
+                verifyKeyForString(key, node.key);
+            },
+            'JSONProperty:exit'() {
+                keyStack = keyStack.upper;
+            },
+            'JSONArrayExpression > *'(node) {
+                const key = node.parent.elements.indexOf(node);
+                verifyKeyForNumber(key, node);
+            }
+        };
+    }
+    function createVisitorForYaml(targetLocaleMessage) {
+        const yamlKeyNodes = new Set();
+        let keyStack = {
+            inLocale: targetLocaleMessage.isResolvedLocaleByFileName()
+        };
+        function withinKey(node) {
+            for (const keyNode of yamlKeyNodes) {
+                if (keyNode.range[0] <= node.range[0] &&
+                    node.range[0] < keyNode.range[1]) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        return {
+            YAMLPair(node) {
+                const { inLocale } = keyStack;
+                keyStack = {
+                    node,
+                    inLocale: true,
+                    upper: keyStack
+                };
+                if (!inLocale) {
+                    return;
+                }
+                if (node.key != null) {
+                    if (withinKey(node)) {
+                        return;
+                    }
+                    yamlKeyNodes.add(node.key);
+                }
+                if (node.key == null) {
+                    reportUnknown(node);
+                }
+                else if (node.key.type === 'YAMLScalar') {
+                    const keyValue = node.key.value;
+                    const key = typeof keyValue === 'string' ? keyValue : String(keyValue);
+                    verifyKeyForString(key, node.key);
+                }
+                else {
+                    reportUnknown(node);
+                }
+            },
+            'YAMLPair:exit'() {
+                keyStack = keyStack.upper;
+            },
+            'YAMLSequence > *'(node) {
+                if (withinKey(node)) {
+                    return;
+                }
+                const key = node.parent.entries.indexOf(node);
+                verifyKeyForNumber(key, node);
+            }
+        };
+    }
+    if ((0, path_1.extname)(filename) === '.vue') {
+        return (0, index_1.defineCustomBlocksVisitor)(context, ctx => {
+            const localeMessages = (0, index_1.getLocaleMessages)(context);
+            const targetLocaleMessage = localeMessages.findBlockLocaleMessage(ctx.parserServices.customBlock);
+            if (!targetLocaleMessage) {
+                return {};
+            }
+            return createVisitorForJson(targetLocaleMessage);
+        }, ctx => {
+            const localeMessages = (0, index_1.getLocaleMessages)(context);
+            const targetLocaleMessage = localeMessages.findBlockLocaleMessage(ctx.parserServices.customBlock);
+            if (!targetLocaleMessage) {
+                return {};
+            }
+            return createVisitorForYaml(targetLocaleMessage);
+        });
+    }
+    else if (sourceCode.parserServices.isJSON ||
+        sourceCode.parserServices.isYAML) {
+        const localeMessages = (0, index_1.getLocaleMessages)(context);
+        const targetLocaleMessage = localeMessages.findExistLocaleMessage(filename);
+        if (!targetLocaleMessage) {
+            debug(`ignore ${filename} in key-format-style`);
+            return {};
+        }
+        if (sourceCode.parserServices.isJSON) {
+            return createVisitorForJson(targetLocaleMessage);
+        }
+        else if (sourceCode.parserServices.isYAML) {
+            return createVisitorForYaml(targetLocaleMessage);
+        }
+        return {};
+    }
+    else {
+        debug(`ignore ${filename} in key-format-style`);
+        return {};
+    }
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'enforce specific casing for localization keys',
+            category: 'Best Practices',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/key-format-style.html',
+            recommended: false
+        },
+        fixable: null,
+        schema: [
+            {
+                enum: [...allowedCaseOptions]
+            },
+            {
+                type: 'object',
+                properties: {
+                    allowArray: {
+                        type: 'boolean'
+                    },
+                    splitByDots: {
+                        type: 'boolean'
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+    create
+});

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-deprecated-i18n-component.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types").RuleModule;
+export = _default;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-deprecated-i18n-component.js

@@ -0,0 +1,85 @@
+"use strict";
+const index_1 = require("../utils/index");
+const rule_1 = require("../utils/rule");
+const compat_1 = require("../utils/compat");
+function create(context) {
+    return (0, index_1.defineTemplateBodyVisitor)(context, {
+        VElement(node) {
+            if (node.name !== 'i18n') {
+                return;
+            }
+            const sourceCode = (0, compat_1.getSourceCode)(context);
+            const tokenStore = sourceCode.parserServices.getTemplateBodyTokenStore();
+            const tagNameToken = tokenStore.getFirstToken(node.startTag);
+            context.report({
+                node: tagNameToken,
+                messageId: 'deprecated',
+                *fix(fixer) {
+                    yield fixer.replaceText(tagNameToken, '<i18n-t');
+                    let hasTag = false;
+                    for (const attr of node.startTag.attributes) {
+                        if (attr.directive) {
+                            if (attr.key.name.name !== 'bind') {
+                                continue;
+                            }
+                            if (!attr.key.argument ||
+                                attr.key.argument.type !== 'VIdentifier') {
+                                continue;
+                            }
+                            if (attr.key.argument.name === 'path') {
+                                yield fixer.replaceText(attr.key.argument, 'keypath');
+                            }
+                            else if (attr.key.argument.name === 'tag') {
+                                hasTag = true;
+                                if (attr.value &&
+                                    attr.value.expression &&
+                                    attr.value.expression.type === 'Literal' &&
+                                    typeof attr.value.expression.value === 'boolean') {
+                                    if (attr.value.expression.value) {
+                                        yield fixer.replaceText(attr, 'tag="span"');
+                                    }
+                                    else {
+                                        yield fixer.remove(attr);
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            if (attr.key.name === 'path') {
+                                yield fixer.replaceText(attr.key, 'keypath');
+                            }
+                            else if (attr.key.name === 'tag') {
+                                hasTag = true;
+                            }
+                        }
+                    }
+                    if (!hasTag) {
+                        yield fixer.insertTextAfter((node.startTag.attributes.length > 0 &&
+                            node.startTag.attributes[node.startTag.attributes.length - 1]) ||
+                            tagNameToken, ' tag="span"');
+                    }
+                    if (node.endTag) {
+                        yield fixer.replaceText(tokenStore.getFirstToken(node.endTag), '</i18n-t');
+                    }
+                }
+            });
+        }
+    });
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'disallow using deprecated `<i18n>` components (in Vue I18n 9.0.0+)',
+            category: 'Recommended',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/no-deprecated-i18n-component.html',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            deprecated: 'Deprecated <i18n> component was found. For VueI18n v9.0, use <i18n-t> component instead.'
+        }
+    },
+    create
+});

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-deprecated-i18n-place-attr.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types").RuleModule;
+export = _default;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-deprecated-i18n-place-attr.js

@@ -0,0 +1,41 @@
+"use strict";
+const index_1 = require("../utils/index");
+const rule_1 = require("../utils/rule");
+function create(context) {
+    return (0, index_1.defineTemplateBodyVisitor)(context, {
+        VElement(node) {
+            if (node.name !== 'i18n' && node.name !== 'i18n-t') {
+                return;
+            }
+            for (const child of node.children) {
+                if (child.type !== 'VElement') {
+                    continue;
+                }
+                const placeAttr = (0, index_1.getAttribute)(child, 'place') || (0, index_1.getDirective)(child, 'bind', 'place');
+                if (placeAttr) {
+                    context.report({
+                        node: placeAttr.key,
+                        messageId: 'deprecated'
+                    });
+                }
+            }
+        }
+    });
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'disallow using deprecated `place` attribute (Removed in Vue I18n 9.0.0+)',
+            category: 'Recommended',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/no-deprecated-i18n-place-attr.html',
+            recommended: true
+        },
+        fixable: null,
+        schema: [],
+        messages: {
+            deprecated: 'Deprecated `place` attribute was found. Use v-slot instead.'
+        }
+    },
+    create
+});

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-deprecated-i18n-places-prop.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types").RuleModule;
+export = _default;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-deprecated-i18n-places-prop.js

@@ -0,0 +1,36 @@
+"use strict";
+const index_1 = require("../utils/index");
+const rule_1 = require("../utils/rule");
+function create(context) {
+    return (0, index_1.defineTemplateBodyVisitor)(context, {
+        VElement(node) {
+            if (node.name !== 'i18n' && node.name !== 'i18n-t') {
+                return;
+            }
+            const placesProp = (0, index_1.getAttribute)(node, 'places') || (0, index_1.getDirective)(node, 'bind', 'places');
+            if (placesProp) {
+                context.report({
+                    node: placesProp.key,
+                    messageId: 'deprecated'
+                });
+            }
+        }
+    });
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'disallow using deprecated `places` prop (Removed in Vue I18n 9.0.0+)',
+            category: 'Recommended',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/no-deprecated-i18n-places-prop.html',
+            recommended: true
+        },
+        fixable: null,
+        schema: [],
+        messages: {
+            deprecated: 'Deprecated `places` prop was found. Use v-slot instead.'
+        }
+    },
+    create
+});

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-deprecated-modulo-syntax.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types").RuleModule;
+export = _default;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-deprecated-modulo-syntax.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_path_1 = require("node:path");
+const debug_1 = __importDefault(require("debug"));
+const index_1 = require("../utils/index");
+const utils_1 = require("../utils/message-compiler/utils");
+const parser_v9_1 = require("../utils/message-compiler/parser-v9");
+const traverser_1 = require("../utils/message-compiler/traverser");
+const rule_1 = require("../utils/rule");
+const compat_1 = require("../utils/compat");
+const debug = (0, debug_1.default)('eslint-plugin-vue-i18n:no-deprecated-modulo-syntax');
+function create(context) {
+    const filename = (0, compat_1.getFilename)(context);
+    const sourceCode = (0, compat_1.getSourceCode)(context);
+    const messageSyntaxVersions = (0, utils_1.getMessageSyntaxVersions)(context);
+    function verifyForV9(message, reportNode, getReportOffset) {
+        const { ast, errors } = (0, parser_v9_1.parse)(message);
+        if (errors.length) {
+            return;
+        }
+        (0, traverser_1.traverseNode)(ast, node => {
+            if (node.type !== utils_1.NodeTypes.Named || !node.modulo) {
+                return;
+            }
+            let range = null;
+            const start = getReportOffset(node.loc.start.offset);
+            const end = getReportOffset(node.loc.end.offset);
+            if (start != null && end != null) {
+                range = [start - 1, end];
+            }
+            context.report({
+                loc: range
+                    ? {
+                        start: sourceCode.getLocFromIndex(range[0]),
+                        end: sourceCode.getLocFromIndex(range[1])
+                    }
+                    : reportNode.loc,
+                message: 'The modulo interpolation must be enforced to named interpolation.',
+                fix(fixer) {
+                    return range ? fixer.removeRange([range[0], range[0] + 1]) : null;
+                }
+            });
+        });
+    }
+    function verifyMessage(message, reportNode, getReportOffset) {
+        if (messageSyntaxVersions.reportIfMissingSetting()) {
+            return;
+        }
+        if (messageSyntaxVersions.v9) {
+            verifyForV9(message, reportNode, getReportOffset);
+        }
+    }
+    const createVisitorForJson = (0, rule_1.defineCreateVisitorForJson)(verifyMessage);
+    const createVisitorForYaml = (0, rule_1.defineCreateVisitorForYaml)(verifyMessage);
+    if ((0, node_path_1.extname)(filename) === '.vue') {
+        return (0, index_1.defineCustomBlocksVisitor)(context, createVisitorForJson, createVisitorForYaml);
+    }
+    else if (sourceCode.parserServices.isJSON ||
+        sourceCode.parserServices.isYAML) {
+        const localeMessages = (0, index_1.getLocaleMessages)(context);
+        const targetLocaleMessage = localeMessages.findExistLocaleMessage(filename);
+        if (!targetLocaleMessage) {
+            debug(`ignore ${filename} in no-deprecated-modulo-syntax`);
+            return {};
+        }
+        if (sourceCode.parserServices.isJSON) {
+            return createVisitorForJson(context);
+        }
+        else if (sourceCode.parserServices.isYAML) {
+            return createVisitorForYaml(context);
+        }
+        return {};
+    }
+    else {
+        debug(`ignore ${filename} in no-deprecated-modulo-syntax`);
+        return {};
+    }
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'enforce modulo interpolation to be named interpolation',
+            category: 'Recommended',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/no-deprecated-modulo-syntax.html',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: []
+    },
+    create
+});

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-deprecated-tc.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types").RuleModule;
+export = _default;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-deprecated-tc.js

@@ -0,0 +1,42 @@
+"use strict";
+const index_1 = require("../utils/index");
+const rule_1 = require("../utils/rule");
+function checkCallExpression(context, node) {
+    const funcName = (node.callee.type === 'MemberExpression' &&
+        node.callee.property.type === 'Identifier' &&
+        node.callee.property.name) ||
+        (node.callee.type === 'Identifier' && node.callee.name) ||
+        '';
+    if (/^(\$tc|tc)$/.test(funcName)) {
+        context.report({
+            node,
+            message: `'${funcName}' is used, but it is deprecated. Use 't' or '$t' instead.`
+        });
+        return;
+    }
+}
+function create(context) {
+    return (0, index_1.defineTemplateBodyVisitor)(context, {
+        CallExpression(node) {
+            checkCallExpression(context, node);
+        }
+    }, {
+        CallExpression(node) {
+            checkCallExpression(context, node);
+        }
+    });
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'disallow using deprecated `tc` or `$tc` (Deprecated in Vue I18n 10.0.0, removed fully in Vue I18n 11.0.0)',
+            category: 'Recommended',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/no-deprecated-tc.html',
+            recommended: true
+        },
+        fixable: null,
+        schema: []
+    },
+    create
+});

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-deprecated-v-t.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types").RuleModule;
+export = _default;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-deprecated-v-t.js

@@ -0,0 +1,33 @@
+"use strict";
+const index_1 = require("../utils/index");
+const rule_1 = require("../utils/rule");
+function checkDirective(context, node) {
+    context.report({
+        node,
+        message: `'v-t' custom directive is used, but it is deprecated. Use 't' or '$t' instead.`
+    });
+}
+function create(context) {
+    return (0, index_1.defineTemplateBodyVisitor)(context, {
+        "VAttribute[directive=true][key.name='t']"(node) {
+            checkDirective(context, node);
+        },
+        "VAttribute[directive=true][key.name.name='t']"(node) {
+            checkDirective(context, node);
+        }
+    });
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'disallow using deprecated `v-t` custom directive (Deprecated in Vue I18n 11.0.0, removed fully in Vue I18n 12.0.0)',
+            category: 'Recommended',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/no-deprecated-v-t.html',
+            recommended: true
+        },
+        fixable: null,
+        schema: []
+    },
+    create
+});