@alexlit/lint-kit 167.2.0 → 167.4.0

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

@@ -0,0 +1,50 @@
+"use strict";
+const index_1 = require("../utils/index");
+const rule_1 = require("../utils/rule");
+function checkDirective(context, node) {
+    if (node.value &&
+        node.value.type === 'VExpressionContainer' &&
+        node.value.expression &&
+        node.value.expression.type === 'CallExpression') {
+        const expressionNode = node.value.expression;
+        const funcName = (expressionNode.callee.type === 'MemberExpression' &&
+            expressionNode.callee.property.type === 'Identifier' &&
+            expressionNode.callee.property.name) ||
+            (expressionNode.callee.type === 'Identifier' &&
+                expressionNode.callee.name) ||
+            '';
+        if (!/^(\$t|t|\$tc|tc)$/.test(funcName) ||
+            !expressionNode.arguments ||
+            !expressionNode.arguments.length) {
+            return;
+        }
+        context.report({
+            node,
+            message: `Using ${funcName} on 'v-html' directive can lead to XSS attack.`
+        });
+    }
+}
+function create(context) {
+    return (0, index_1.defineTemplateBodyVisitor)(context, {
+        "VAttribute[directive=true][key.name='html']"(node) {
+            checkDirective(context, node);
+        },
+        "VAttribute[directive=true][key.name.name='html']"(node) {
+            checkDirective(context, node);
+        }
+    });
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'disallow use of localization methods on v-html to prevent XSS attack',
+            category: 'Recommended',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/no-v-html.html',
+            recommended: true
+        },
+        fixable: null,
+        schema: []
+    },
+    create
+});

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/prefer-linked-key-with-paren.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/prefer-linked-key-with-paren.js

@@ -0,0 +1,108 @@
+"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 rule_1 = require("../utils/rule");
+const index_1 = require("../utils/index");
+const utils_1 = require("../utils/message-compiler/utils");
+const parser_1 = require("../utils/message-compiler/parser");
+const traverser_1 = require("../utils/message-compiler/traverser");
+const compat_1 = require("../utils/compat");
+const debug = (0, debug_1.default)('eslint-plugin-vue-i18n:prefer-linked-key-with-paren');
+function getSingleQuote(node) {
+    if (node.type === 'JSONLiteral') {
+        return node.raw[0] !== "'" ? "'" : "\\'";
+    }
+    if (node.style === 'single-quoted') {
+        return "''";
+    }
+    return "'";
+}
+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 verifySyntax(message, reportNode, getReportOffset) {
+        const { ast, errors } = (0, parser_1.parse)(message);
+        if (errors.length) {
+            return;
+        }
+        (0, traverser_1.traverseNode)(ast, node => {
+            if (node.type !== utils_1.NodeTypes.LinkedKey) {
+                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, end];
+            }
+            context.report({
+                loc: range
+                    ? {
+                        start: sourceCode.getLocFromIndex(range[0]),
+                        end: sourceCode.getLocFromIndex(range[1])
+                    }
+                    : reportNode.loc,
+                message: 'The linked message key must be enclosed in brackets.',
+                fix(fixer) {
+                    if (!range) {
+                        return null;
+                    }
+                    const single = getSingleQuote(reportNode);
+                    return [
+                        fixer.insertTextBeforeRange(range, `{${single}`),
+                        fixer.insertTextAfterRange(range, `${single}}`)
+                    ];
+                }
+            });
+        });
+    }
+    function verifyMessage(message, reportNode, getReportOffset) {
+        if (messageSyntaxVersions.reportIfMissingSetting()) {
+            return;
+        }
+        verifySyntax(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 prefer-linked-key-with-paren`);
+            return {};
+        }
+        if (sourceCode.parserServices.isJSON) {
+            return createVisitorForJson(context);
+        }
+        else if (sourceCode.parserServices.isYAML) {
+            return createVisitorForYaml(context);
+        }
+        return {};
+    }
+    else {
+        debug(`ignore ${filename} in prefer-linked-key-with-paren`);
+        return {};
+    }
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'enforce linked key to be enclosed in parentheses',
+            category: 'Stylistic Issues',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/prefer-linked-key-with-paren.html',
+            recommended: false
+        },
+        fixable: 'code',
+        schema: []
+    },
+    create
+});

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/prefer-sfc-lang-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/prefer-sfc-lang-attr.js

@@ -0,0 +1,58 @@
+"use strict";
+const index_1 = require("../utils/index");
+const rule_1 = require("../utils/rule");
+const compat_1 = require("../utils/compat");
+function create(context) {
+    var _a, _b;
+    const sourceCode = (0, compat_1.getSourceCode)(context);
+    const df = (_b = (_a = sourceCode.parserServices).getDocumentFragment) === null || _b === void 0 ? void 0 : _b.call(_a);
+    if (!df) {
+        return {};
+    }
+    return {
+        Program() {
+            var _a, _b;
+            for (const i18n of df.children.filter(index_1.isI18nBlock)) {
+                const srcAttrs = (0, index_1.getAttribute)(i18n, 'src');
+                if (srcAttrs != null) {
+                    continue;
+                }
+                const langAttrs = (0, index_1.getAttribute)(i18n, 'lang');
+                if (langAttrs == null ||
+                    langAttrs.value == null ||
+                    !langAttrs.value.value) {
+                    context.report({
+                        loc: ((_b = (_a = langAttrs === null || langAttrs === void 0 ? void 0 : langAttrs.value) !== null && _a !== void 0 ? _a : langAttrs) !== null && _b !== void 0 ? _b : i18n.startTag).loc,
+                        messageId: 'required',
+                        fix(fixer) {
+                            if (langAttrs) {
+                                return fixer.replaceTextRange(langAttrs.range, 'lang="json"');
+                            }
+                            const tokenStore = sourceCode.parserServices.getTemplateBodyTokenStore();
+                            const closeToken = tokenStore.getLastToken(i18n.startTag);
+                            const beforeToken = tokenStore.getTokenBefore(closeToken);
+                            return fixer.insertTextBeforeRange(closeToken.range, `${beforeToken.range[1] < closeToken.range[0] ? '' : ' '}lang="json" `);
+                        }
+                    });
+                }
+            }
+        }
+    };
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'require lang attribute on `<i18n>` block',
+            category: 'Best Practices',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/prefer-sfc-lang-attr.html',
+            recommended: false
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            required: '`lang` attribute is required.'
+        }
+    },
+    create
+});

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

@@ -0,0 +1,65 @@
+"use strict";
+const compat_1 = require("../utils/compat");
+const index_1 = require("../utils/index");
+const rule_1 = require("../utils/rule");
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'require or disallow the locale attribute on `<i18n>` block',
+            category: 'Stylistic Issues',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/sfc-locale-attr.html',
+            recommended: false
+        },
+        fixable: null,
+        schema: [
+            {
+                enum: ['always', 'never']
+            }
+        ],
+        messages: {
+            required: '`locale` attribute is required.',
+            disallowed: '`locale` attribute is disallowed.'
+        }
+    },
+    create(context) {
+        var _a, _b;
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        const df = (_b = (_a = sourceCode.parserServices).getDocumentFragment) === null || _b === void 0 ? void 0 : _b.call(_a);
+        if (!df) {
+            return {};
+        }
+        const always = context.options[0] !== 'never';
+        return {
+            Program() {
+                for (const i18n of df.children.filter(index_1.isI18nBlock)) {
+                    const srcAttrs = (0, index_1.getAttribute)(i18n, 'src');
+                    if (srcAttrs != null) {
+                        continue;
+                    }
+                    const localeAttrs = (0, index_1.getAttribute)(i18n, 'locale');
+                    if (localeAttrs != null &&
+                        localeAttrs.value != null &&
+                        localeAttrs.value.value) {
+                        if (always) {
+                            continue;
+                        }
+                        context.report({
+                            loc: localeAttrs.loc,
+                            messageId: 'disallowed'
+                        });
+                    }
+                    else {
+                        if (!always) {
+                            continue;
+                        }
+                        context.report({
+                            loc: i18n.startTag.loc,
+                            messageId: 'required'
+                        });
+                    }
+                }
+            }
+        };
+    }
+});

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/rules/valid-message-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/valid-message-syntax.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const jsonc_eslint_parser_1 = require("jsonc-eslint-parser");
+const yaml_eslint_parser_1 = require("yaml-eslint-parser");
+const path_1 = require("path");
+const index_1 = require("../utils/index");
+const debug_1 = __importDefault(require("debug"));
+const utils_1 = require("../utils/message-compiler/utils");
+const parser_1 = require("../utils/message-compiler/parser");
+const parser_v9_1 = require("../utils/message-compiler/parser-v9");
+const rule_1 = require("../utils/rule");
+const compat_1 = require("../utils/compat");
+const debug = (0, debug_1.default)('eslint-plugin-vue-i18n:valid-message-syntax');
+function create(context) {
+    var _a;
+    const filename = (0, compat_1.getFilename)(context);
+    const sourceCode = (0, compat_1.getSourceCode)(context);
+    const allowNotString = Boolean((_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.allowNotString);
+    const messageSyntaxVersions = (0, utils_1.getMessageSyntaxVersions)(context);
+    function* extractMessageErrors(message) {
+        const errors = [];
+        if (messageSyntaxVersions.v10 || messageSyntaxVersions.v11) {
+            errors.push(...(0, parser_1.parse)(message).errors);
+        }
+        if (messageSyntaxVersions.v9 && !errors.length) {
+            errors.push(...(0, parser_v9_1.parse)(message).errors);
+        }
+        yield* errors;
+    }
+    function verifyMessage(message, reportNode, getReportOffset) {
+        if (typeof message !== 'string') {
+            if (!allowNotString) {
+                const type = message === null
+                    ? 'null'
+                    : message instanceof RegExp
+                        ? 'RegExp'
+                        : typeof message;
+                context.report({
+                    message: `Unexpected '${type}' message`,
+                    loc: reportNode.loc
+                });
+            }
+        }
+        else {
+            for (const error of extractMessageErrors(message)) {
+                messageSyntaxVersions.reportIfMissingSetting();
+                const reportOffset = getReportOffset === null || getReportOffset === void 0 ? void 0 : getReportOffset(error);
+                context.report({
+                    message: error.message,
+                    loc: reportOffset != null
+                        ? sourceCode.getLocFromIndex(reportOffset)
+                        : reportNode.loc
+                });
+            }
+        }
+    }
+    function createVisitorForJson() {
+        function verifyExpression(node, parent) {
+            let message;
+            let getReportOffset = null;
+            if (node) {
+                if (node.type === 'JSONArrayExpression' ||
+                    node.type === 'JSONObjectExpression') {
+                    return;
+                }
+                message = (0, jsonc_eslint_parser_1.getStaticJSONValue)(node);
+                getReportOffset = error => (0, utils_1.getReportIndex)(node, error.location.start.offset);
+            }
+            else {
+                message = null;
+            }
+            verifyMessage(message, node || parent, getReportOffset);
+        }
+        return {
+            JSONProperty(node) {
+                verifyExpression(node.value, node);
+            },
+            JSONArrayExpression(node) {
+                for (const element of node.elements) {
+                    verifyExpression(element, node);
+                }
+            }
+        };
+    }
+    function createVisitorForYaml() {
+        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;
+        }
+        function verifyContent(node, parent) {
+            let message;
+            let getReportOffset = null;
+            if (node) {
+                const valueNode = node.type === 'YAMLWithMeta' ? node.value : node;
+                if (!valueNode ||
+                    valueNode.type === 'YAMLMapping' ||
+                    valueNode.type === 'YAMLSequence') {
+                    return;
+                }
+                message = (0, yaml_eslint_parser_1.getStaticYAMLValue)(node);
+                getReportOffset = error => (0, utils_1.getReportIndex)(valueNode, error.location.start.offset);
+            }
+            else {
+                message = null;
+            }
+            if (message != null && typeof message === 'object') {
+                return;
+            }
+            verifyMessage(message, node || parent, getReportOffset);
+        }
+        return {
+            YAMLPair(node) {
+                if (withinKey(node)) {
+                    return;
+                }
+                if (node.key != null) {
+                    yamlKeyNodes.add(node.key);
+                }
+                verifyContent(node.value, node);
+            },
+            YAMLSequence(node) {
+                if (withinKey(node)) {
+                    return;
+                }
+                for (const entry of node.entries) {
+                    verifyContent(entry, node);
+                }
+            }
+        };
+    }
+    if ((0, 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 valid-message-syntax`);
+            return {};
+        }
+        if (sourceCode.parserServices.isJSON) {
+            return createVisitorForJson();
+        }
+        else if (sourceCode.parserServices.isYAML) {
+            return createVisitorForYaml();
+        }
+        return {};
+    }
+    else {
+        debug(`ignore ${filename} in valid-message-syntax`);
+        return {};
+    }
+}
+module.exports = (0, rule_1.createRule)({
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'disallow invalid message syntax',
+            category: 'Recommended',
+            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/valid-message-syntax.html',
+            recommended: true
+        },
+        fixable: null,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowNotString: {
+                        type: 'boolean'
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+    create
+});