@alexlit/lint-kit 167.3.0 → 167.4.0

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-duplicate-keys-in-locale.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-duplicate-keys-in-locale.js

@@ -0,0 +1,271 @@
+"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 key_path_1 = require("../utils/key-path");
+const get_cwd_1 = require("../utils/get-cwd");
+const rule_1 = require("../utils/rule");
+const compat_1 = require("../utils/compat");
+const debug = (0, debug_1.default)('eslint-plugin-vue-i18n:no-duplicate-keys-in-locale');
+function getMessageFilepath(fullPath, context) {
+    const cwd = (0, get_cwd_1.getCwd)(context);
+    if (fullPath.startsWith(cwd)) {
+        return fullPath.replace(`${cwd}/`, './');
+    }
+    return fullPath;
+}
+function create(context) {
+    const filename = (0, compat_1.getFilename)(context);
+    const sourceCode = (0, compat_1.getSourceCode)(context);
+    const options = (context.options && context.options[0]) || {};
+    const ignoreI18nBlock = Boolean(options.ignoreI18nBlock);
+    function createInitPathStack(targetLocaleMessage, otherLocaleMessages) {
+        if (targetLocaleMessage.isResolvedLocaleByFileName()) {
+            const locale = targetLocaleMessage.locales[0];
+            return createInitLocalePathStack(locale, otherLocaleMessages);
+        }
+        else {
+            return {
+                keyPath: [],
+                locale: null,
+                otherDictionaries: []
+            };
+        }
+    }
+    function createInitLocalePathStack(locale, otherLocaleMessages) {
+        return {
+            keyPath: [],
+            locale,
+            otherDictionaries: otherLocaleMessages.map(lm => {
+                return {
+                    dict: lm.getMessagesFromLocale(locale),
+                    source: lm
+                };
+            })
+        };
+    }
+    function createVerifyContext(targetLocaleMessage, otherLocaleMessages) {
+        let pathStack = createInitPathStack(targetLocaleMessage, otherLocaleMessages);
+        const existsKeyNodes = {};
+        const existsLocaleNodes = {};
+        function pushKey(exists, key, reportNode) {
+            const keyNodes = exists[key] || (exists[key] = []);
+            keyNodes.push(reportNode);
+        }
+        return {
+            enterKey(key, reportNode) {
+                if (pathStack.locale == null) {
+                    const locale = key;
+                    pushKey(existsLocaleNodes, locale, reportNode);
+                    pathStack = Object.assign({ upper: pathStack, node: reportNode }, createInitLocalePathStack(locale, otherLocaleMessages));
+                    return;
+                }
+                const keyOtherValues = pathStack.otherDictionaries.map(dict => {
+                    return {
+                        value: dict.dict[key],
+                        source: dict.source
+                    };
+                });
+                const keyPath = [...pathStack.keyPath, key];
+                const keyPathStr = (0, key_path_1.joinPath)(...keyPath);
+                const nextOtherDictionaries = [];
+                const reportFiles = [];
+                for (const value of keyOtherValues) {
+                    if (value.value == null) {
+                        continue;
+                    }
+                    if (typeof value.value !== 'object') {
+                        reportFiles.push(`"${getMessageFilepath(value.source.fullpath, context)}"`);
+                    }
+                    else {
+                        nextOtherDictionaries.push({
+                            dict: value.value,
+                            source: value.source
+                        });
+                    }
+                }
+                if (reportFiles.length) {
+                    reportFiles.sort();
+                    const last = reportFiles.pop();
+                    context.report({
+                        message: `duplicate key '${keyPathStr}' in '${pathStack.locale}'. ${reportFiles.length === 0
+                            ? last
+                            : `${reportFiles.join(', ')}, and ${last}`} has the same key`,
+                        loc: reportNode.loc
+                    });
+                }
+                pushKey(existsKeyNodes[pathStack.locale] ||
+                    (existsKeyNodes[pathStack.locale] = {}), keyPathStr, reportNode);
+                pathStack = {
+                    upper: pathStack,
+                    node: reportNode,
+                    keyPath,
+                    locale: pathStack.locale,
+                    otherDictionaries: nextOtherDictionaries
+                };
+            },
+            leaveKey(node) {
+                if (pathStack.node === node) {
+                    pathStack = pathStack.upper;
+                }
+            },
+            reports() {
+                for (const localeNodes of [
+                    existsLocaleNodes,
+                    ...Object.values(existsKeyNodes)
+                ]) {
+                    for (const key of Object.keys(localeNodes)) {
+                        const keyNodes = localeNodes[key];
+                        if (keyNodes.length > 1) {
+                            for (const keyNode of keyNodes) {
+                                context.report({
+                                    message: `duplicate key '${key}'`,
+                                    loc: keyNode.loc
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        };
+    }
+    function createVisitorForJson(_sourceCode, targetLocaleMessage, otherLocaleMessages) {
+        const verifyContext = createVerifyContext(targetLocaleMessage, otherLocaleMessages);
+        return {
+            JSONProperty(node) {
+                const key = node.key.type === 'JSONLiteral' ? `${node.key.value}` : node.key.name;
+                verifyContext.enterKey(key, node.key);
+            },
+            'JSONProperty:exit'(node) {
+                verifyContext.leaveKey(node.key);
+            },
+            'JSONArrayExpression > *'(node) {
+                const key = node.parent.elements.indexOf(node);
+                verifyContext.enterKey(key, node);
+            },
+            'JSONArrayExpression > *:exit'(node) {
+                verifyContext.leaveKey(node);
+            },
+            'Program:exit'() {
+                verifyContext.reports();
+            }
+        };
+    }
+    function createVisitorForYaml(sourceCode, targetLocaleMessage, otherLocaleMessages) {
+        const verifyContext = createVerifyContext(targetLocaleMessage, otherLocaleMessages);
+        const yamlKeyNodes = new Set();
+        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) {
+                if (node.key != null) {
+                    if (withinKey(node)) {
+                        return;
+                    }
+                    yamlKeyNodes.add(node.key);
+                }
+                else {
+                    return;
+                }
+                const keyValue = node.key.type !== 'YAMLScalar'
+                    ? sourceCode.getText(node.key)
+                    : node.key.value;
+                const key = typeof keyValue === 'boolean' || keyValue === null
+                    ? String(keyValue)
+                    : keyValue;
+                verifyContext.enterKey(key, node.key);
+            },
+            'YAMLPair:exit'(node) {
+                verifyContext.leaveKey(node.key);
+            },
+            'YAMLSequence > *'(node) {
+                const key = node.parent.entries.indexOf(node);
+                verifyContext.enterKey(key, node);
+            },
+            'YAMLSequence > *:exit'(node) {
+                verifyContext.leaveKey(node);
+            },
+            'Program:exit'() {
+                verifyContext.reports();
+            }
+        };
+    }
+    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 {};
+            }
+            const otherLocaleMessages = ignoreI18nBlock
+                ? []
+                : localeMessages.localeMessages.filter(lm => lm !== targetLocaleMessage);
+            return createVisitorForJson((0, compat_1.getSourceCode)(ctx), targetLocaleMessage, otherLocaleMessages);
+        }, ctx => {
+            const localeMessages = (0, index_1.getLocaleMessages)(context);
+            const targetLocaleMessage = localeMessages.findBlockLocaleMessage(ctx.parserServices.customBlock);
+            if (!targetLocaleMessage) {
+                return {};
+            }
+            const otherLocaleMessages = ignoreI18nBlock
+                ? []
+                : localeMessages.localeMessages.filter(lm => lm !== targetLocaleMessage);
+            return createVisitorForYaml((0, compat_1.getSourceCode)(ctx), targetLocaleMessage, otherLocaleMessages);
+        });
+    }
+    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-duplicate-keys-in-locale`);
+            return {};
+        }
+        const otherLocaleMessages = localeMessages.localeMessages.filter(lm => lm !== targetLocaleMessage);
+        if (sourceCode.parserServices.isJSON) {
+            return createVisitorForJson(sourceCode, targetLocaleMessage, otherLocaleMessages);
+        }
+        else if (sourceCode.parserServices.isYAML) {
+            return createVisitorForYaml(sourceCode, targetLocaleMessage, otherLocaleMessages);
+        }
+        return {};
+    }
+    else {
+        debug(`ignore ${filename} in no-duplicate-keys-in-locale`);
+        return {};
+    }
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'disallow duplicate localization keys within the same locale',
+            category: 'Best Practices',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/no-duplicate-keys-in-locale.html',
+            recommended: false
+        },
+        fixable: null,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    ignoreI18nBlock: {
+                        type: 'boolean'
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+    create
+});

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-dynamic-keys.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-dynamic-keys.js

@@ -0,0 +1,105 @@
+"use strict";
+const index_1 = require("../utils/index");
+const rule_1 = require("../utils/rule");
+const compat_1 = require("../utils/compat");
+function getNodeName(context, node) {
+    if (node.type === 'Identifier') {
+        return node.name;
+    }
+    const sourceCode = (0, compat_1.getSourceCode)(context);
+    if (sourceCode.ast.range[0] <= node.range[0] &&
+        node.range[1] <= sourceCode.ast.range[1]) {
+        return sourceCode
+            .getTokens(node)
+            .map(t => t.value)
+            .join('');
+    }
+    const tokenStore = sourceCode.parserServices.getTemplateBodyTokenStore();
+    return tokenStore
+        .getTokens(node)
+        .map(t => t.value)
+        .join('');
+}
+function checkDirective(context, node) {
+    if (node.value &&
+        node.value.type === 'VExpressionContainer' &&
+        node.value.expression &&
+        !(0, index_1.isStaticLiteral)(node.value.expression)) {
+        const name = getNodeName(context, node.value.expression);
+        context.report({
+            node,
+            message: `'${name}' dynamic key is used'`
+        });
+    }
+}
+function checkComponent(context, node) {
+    if (node.name.type === 'VIdentifier' &&
+        node.name.name === 'bind' &&
+        node.argument &&
+        node.argument.type === 'VIdentifier' &&
+        node.argument.name === 'path' &&
+        node.parent.value &&
+        node.parent.value.type === 'VExpressionContainer' &&
+        node.parent.value.expression &&
+        !(0, index_1.isStaticLiteral)(node.parent.value.expression)) {
+        const name = getNodeName(context, node.parent.value.expression);
+        context.report({
+            node,
+            message: `'${name}' dynamic key is used'`
+        });
+    }
+}
+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 (!/^(\$t|t|\$tc|tc)$/.test(funcName) ||
+        !node.arguments ||
+        !node.arguments.length) {
+        return;
+    }
+    const [keyNode] = node.arguments;
+    if (!(0, index_1.isStaticLiteral)(keyNode)) {
+        const name = getNodeName(context, keyNode);
+        context.report({
+            node,
+            message: `'${name}' dynamic key is used'`
+        });
+    }
+}
+function create(context) {
+    return (0, index_1.compositingVisitors)((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);
+        },
+        'VElement:matches([name=i18n], [name=i18n-t]) > VStartTag > VAttribute[directive=true] > VDirectiveKey'(node) {
+            checkComponent(context, node);
+        },
+        CallExpression(node) {
+            checkCallExpression(context, node);
+        }
+    }), {
+        CallExpression(node) {
+            checkCallExpression(context, node);
+        }
+    });
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'disallow localization dynamic keys at localization methods',
+            category: 'Best Practices',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/no-dynamic-keys.html',
+            recommended: false
+        },
+        fixable: null,
+        schema: []
+    },
+    create
+});

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-html-messages.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-html-messages.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const path_1 = require("path");
+const parse5 = __importStar(require("parse5"));
+const index_1 = require("../utils/index");
+const debug_1 = __importDefault(require("debug"));
+const rule_1 = require("../utils/rule");
+const compat_1 = require("../utils/compat");
+const debug = (0, debug_1.default)('eslint-plugin-vue-i18n:no-html-messages');
+function findHTMLNode(node) {
+    return node.childNodes.find((child) => {
+        if (child.nodeName !== '#text' && child.tagName) {
+            return true;
+        }
+        return false;
+    });
+}
+function create(context) {
+    const filename = (0, compat_1.getFilename)(context);
+    const sourceCode = (0, compat_1.getSourceCode)(context);
+    function verifyJSONLiteral(node) {
+        const parent = node.parent;
+        if (parent.type === 'JSONProperty' && parent.key === node) {
+            return;
+        }
+        const htmlNode = parse5.parseFragment(`${node.value}`, {
+            sourceCodeLocationInfo: true
+        });
+        const foundNode = findHTMLNode(htmlNode);
+        if (!foundNode) {
+            return;
+        }
+        const loc = {
+            line: node.loc.start.line,
+            column: node.loc.start.column +
+                1 +
+                foundNode.sourceCodeLocation.startOffset
+        };
+        context.report({
+            message: `used HTML localization message`,
+            loc
+        });
+    }
+    function verifyYAMLScalar(node) {
+        const parent = node.parent;
+        if (parent.type === 'YAMLPair' && parent.key === node) {
+            return;
+        }
+        const htmlNode = parse5.parseFragment(`${node.value}`, {
+            sourceCodeLocationInfo: true
+        });
+        const foundNode = findHTMLNode(htmlNode);
+        if (!foundNode) {
+            return;
+        }
+        const loc = {
+            line: node.loc.start.line,
+            column: node.loc.start.column +
+                1 +
+                foundNode.sourceCodeLocation.startOffset
+        };
+        context.report({
+            message: `used HTML localization message`,
+            loc
+        });
+    }
+    if ((0, path_1.extname)(filename) === '.vue') {
+        return (0, index_1.defineCustomBlocksVisitor)(context, () => {
+            return {
+                JSONLiteral: verifyJSONLiteral
+            };
+        }, () => {
+            return {
+                YAMLScalar: verifyYAMLScalar
+            };
+        });
+    }
+    else if (sourceCode.parserServices.isJSON) {
+        if (!(0, index_1.getLocaleMessages)(context).findExistLocaleMessage(filename)) {
+            return {};
+        }
+        return {
+            JSONLiteral: verifyJSONLiteral
+        };
+    }
+    else if (sourceCode.parserServices.isYAML) {
+        if (!(0, index_1.getLocaleMessages)(context).findExistLocaleMessage(filename)) {
+            return {};
+        }
+        return {
+            YAMLScalar: verifyYAMLScalar
+        };
+    }
+    else {
+        debug(`ignore ${filename} in no-html-messages`);
+        return {};
+    }
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'disallow use HTML localization messages',
+            category: 'Recommended',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/no-html-messages.html',
+            recommended: true
+        },
+        fixable: null,
+        schema: []
+    },
+    create
+});

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-i18n-t-path-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-i18n-t-path-prop.js

@@ -0,0 +1,44 @@
+"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-t') {
+                return;
+            }
+            const pathProp = (0, index_1.getAttribute)(node, 'path') || (0, index_1.getDirective)(node, 'bind', 'path');
+            if (pathProp) {
+                context.report({
+                    node: pathProp.key,
+                    messageId: 'disallow',
+                    fix(fixer) {
+                        if (pathProp.directive) {
+                            return fixer.replaceText(pathProp.key.argument, 'keypath');
+                        }
+                        else {
+                            return fixer.replaceText(pathProp.key, 'keypath');
+                        }
+                    }
+                });
+            }
+        }
+    });
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'disallow using `path` prop with `<i18n-t>`',
+            category: 'Recommended',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/no-i18n-t-path-prop.html',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            disallow: 'Cannot use `path` prop with `<i18n-t>` component. Use `keypath` prop instead.'
+        }
+    },
+    create
+});

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/no-missing-keys-in-other-locales.d.ts

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