@alexlit/lint-kit 167.2.0 → 167.4.0

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/locale-messages.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocaleMessages = exports.FileLocaleMessage = exports.BlockLocaleMessage = exports.LocaleMessage = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const parsers_1 = require("./parsers");
+const resource_loader_1 = require("./resource-loader");
+const json5_1 = require("json5");
+const js_yaml_1 = require("js-yaml");
+const key_path_1 = require("./key-path");
+const DEFAULT_LOCALE_PATTERN = '[A-Za-z0-9-_]+';
+const DEFAULT_LOCALE_FIELNAME_REGEX = new RegExp(`(${DEFAULT_LOCALE_PATTERN})\.`, 'i');
+const DEFAULT_LOCALE_CAPTURE_REGEX = new RegExp(`^.*\/(?<locale>${DEFAULT_LOCALE_PATTERN})\.(json5?|ya?ml)$`, 'i');
+class LocaleMessage {
+    constructor({ fullpath, locales, localeKey, localePattern }) {
+        this.fullpath = fullpath;
+        this.localeKey = localeKey;
+        this.file = fullpath.replace(/^.*(\\|\/|:)/, '');
+        this.localePattern = this.getLocalePatternWithRegex(localePattern);
+        this._locales = locales;
+    }
+    getLocalePatternWithRegex(localePattern) {
+        return localePattern != null
+            ? typeof localePattern === 'string'
+                ? new RegExp(localePattern, 'i')
+                : Object.prototype.toString.call(localePattern) === '[object RegExp]'
+                    ? localePattern
+                    : DEFAULT_LOCALE_CAPTURE_REGEX
+            : DEFAULT_LOCALE_CAPTURE_REGEX;
+    }
+    get messages() {
+        return this.getMessagesInternal();
+    }
+    get locales() {
+        var _a;
+        if (this._locales) {
+            return this._locales;
+        }
+        if (this.localeKey === 'file') {
+            const matched = this.file.match(DEFAULT_LOCALE_FIELNAME_REGEX);
+            return (this._locales = [(matched && matched[1]) || this.file]);
+        }
+        else if (this.localeKey === 'path') {
+            const matched = this.fullpath.match(this.localePattern);
+            return (this._locales = [
+                (matched && ((_a = matched.groups) === null || _a === void 0 ? void 0 : _a.locale)) || this.fullpath
+            ]);
+        }
+        else if (this.localeKey === 'key') {
+            return (this._locales = Object.keys(this.messages));
+        }
+        return (this._locales = []);
+    }
+    isResolvedLocaleByFileName() {
+        return this.localeKey === 'file' || this.localeKey === 'path';
+    }
+    getMessagesFromLocale(locale) {
+        if (this.isResolvedLocaleByFileName()) {
+            if (!this.locales.includes(locale)) {
+                return {};
+            }
+            return this.messages;
+        }
+        if (this.localeKey === 'key') {
+            return (this.messages[locale] || {});
+        }
+        return {};
+    }
+}
+exports.LocaleMessage = LocaleMessage;
+class BlockLocaleMessage extends LocaleMessage {
+    constructor({ block, fullpath, locales, localeKey, lang = 'json' }) {
+        super({
+            fullpath,
+            locales,
+            localeKey
+        });
+        this._messages = null;
+        this.block = block;
+        this.lang = lang || 'json';
+    }
+    getMessagesInternal() {
+        if (this._messages) {
+            return this._messages;
+        }
+        const { lang } = this;
+        if (lang === 'json' || lang === 'json5') {
+            this._messages = (0, parsers_1.parseJsonValuesInI18nBlock)(this.block) || {};
+        }
+        else if (lang === 'yaml' || lang === 'yml') {
+            this._messages = (0, parsers_1.parseYamlValuesInI18nBlock)(this.block) || {};
+        }
+        else {
+            this._messages = {};
+        }
+        return this._messages;
+    }
+}
+exports.BlockLocaleMessage = BlockLocaleMessage;
+class FileLocaleMessage extends LocaleMessage {
+    constructor({ fullpath, locales, localeKey, localePattern }) {
+        super({
+            fullpath,
+            locales,
+            localeKey,
+            localePattern
+        });
+        this._resource = new resource_loader_1.ResourceLoader(fullpath, fileName => {
+            const ext = (0, path_1.extname)(fileName).toLowerCase();
+            if (ext === '.js') {
+                const key = require.resolve(fileName);
+                delete require.cache[key];
+                return require(fileName);
+            }
+            else if (ext === '.yaml' || ext === '.yml') {
+                return (0, js_yaml_1.load)((0, fs_1.readFileSync)(fileName, 'utf8'));
+            }
+            else if (ext === '.json' || ext === '.json5') {
+                return (0, json5_1.parse)((0, fs_1.readFileSync)(fileName, 'utf8'));
+            }
+        });
+    }
+    getMessagesInternal() {
+        return this._resource.getResource();
+    }
+}
+exports.FileLocaleMessage = FileLocaleMessage;
+class LocaleMessages {
+    constructor(localeMessages) {
+        this.localeMessages = localeMessages;
+    }
+    get locales() {
+        const locales = new Set();
+        for (const localeMessage of this.localeMessages) {
+            for (const locale of localeMessage.locales) {
+                locales.add(locale);
+            }
+        }
+        return [...locales];
+    }
+    isEmpty() {
+        return this.localeMessages.length <= 0;
+    }
+    findExistLocaleMessage(fullpath) {
+        return (this.localeMessages.find(message => message.fullpath === fullpath) || null);
+    }
+    findBlockLocaleMessage(block) {
+        return (this.localeMessages.find((message) => message.block === block) || null);
+    }
+    findMissingPath(key) {
+        let missingPath = [];
+        for (const locale of this.locales) {
+            const localeMessages = this.localeMessages.map(lm => lm.getMessagesFromLocale(locale));
+            if (localeMessages.some(last => {
+                return last && typeof last === 'object' ? last[key] != null : false;
+            })) {
+                return null;
+            }
+            const paths = [...(0, key_path_1.parsePath)(key)];
+            let lasts = localeMessages;
+            const targetPaths = [];
+            let hasMissing = false;
+            while (paths.length) {
+                const path = paths.shift();
+                targetPaths.push(path);
+                const values = lasts
+                    .map(last => {
+                    return last && typeof last === 'object' ? last[path] : undefined;
+                })
+                    .filter((val) => val != null);
+                if (values.length === 0) {
+                    if (missingPath.length <= targetPaths.length) {
+                        missingPath = targetPaths;
+                    }
+                    hasMissing = true;
+                    break;
+                }
+                lasts = values;
+            }
+            if (!hasMissing) {
+                return null;
+            }
+        }
+        return (0, key_path_1.joinPath)(...missingPath);
+    }
+}
+exports.LocaleMessages = LocaleMessages;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/message-compiler/parser-v9.d.ts

@@ -0,0 +1,8 @@
+import type { CompileError, NamedNode, ResourceNode } from '@intlify/message-compiler';
+export type ModuloNamedNode = NamedNode & {
+    modulo?: boolean;
+};
+export declare function parse(code: string): {
+    ast: ResourceNode;
+    errors: CompileError[];
+};

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/message-compiler/parser-v9.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const utils_1 = require("./utils");
+const parser_1 = require("./parser");
+const traverser_1 = require("./traverser");
+function parse(code) {
+    const { ast, errors } = (0, parser_1.parse)(code);
+    (0, traverser_1.traverseNode)(ast, node => {
+        if (node.type === utils_1.NodeTypes.Message) {
+            transformModuloNamedNode(node.items);
+        }
+    });
+    return {
+        ast,
+        errors
+    };
+    function transformModuloNamedNode(nodes) {
+        var _a;
+        for (let index = nodes.length - 1; index >= 1; index--) {
+            const node = nodes[index];
+            if (node.type !== utils_1.NodeTypes.Named ||
+                code[node.loc.start.offset - 1] !== '%')
+                continue;
+            const prev = nodes[index - 1];
+            if (prev.type !== utils_1.NodeTypes.Text || !((_a = prev.value) === null || _a === void 0 ? void 0 : _a.endsWith('%')))
+                continue;
+            node.modulo = true;
+            prev.loc.end.offset -= 1;
+            prev.loc.end.column -= 1;
+            prev.end -= 1;
+            prev.value = prev.value.slice(0, -1);
+            if (prev.start === prev.end) {
+                nodes.splice(index - 1, 1);
+                index--;
+            }
+        }
+    }
+}
+exports.parse = parse;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/message-compiler/parser.d.ts

@@ -0,0 +1,5 @@
+import type { CompileError, ResourceNode } from '@intlify/message-compiler';
+export declare function parse(code: string): {
+    ast: ResourceNode;
+    errors: CompileError[];
+};

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/message-compiler/parser.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const message_compiler_1 = require("@intlify/message-compiler");
+function parse(code) {
+    const errors = [];
+    const parser = (0, message_compiler_1.createParser)({
+        onError(error) {
+            errors.push(error);
+        }
+    });
+    const ast = parser.parse(code);
+    return {
+        ast,
+        errors
+    };
+}
+exports.parse = parse;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/message-compiler/traverser.d.ts

@@ -0,0 +1,6 @@
+import type { LinkedKeyNode, LinkedModifierNode, LinkedNode, ListNode, LiteralNode, MessageNode, NamedNode, PluralNode, ResourceNode, TextNode } from '@intlify/message-compiler';
+import type { ModuloNamedNode } from './parser-v9';
+export type MessageElementNode = TextNode | NamedNode | ListNode | LiteralNode | LinkedNode | ModuloNamedNode;
+type MessageASTNode = ResourceNode | PluralNode | MessageNode | MessageElementNode | LinkedKeyNode | LinkedModifierNode;
+export declare function traverseNode(node: MessageASTNode, visit: (node: MessageASTNode) => void): void;
+export {};

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/message-compiler/traverser.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseNode = void 0;
+const utils_1 = require("./utils");
+function traverseNodes(nodes, visit) {
+    for (let i = 0; i < nodes.length; i++) {
+        traverseNode(nodes[i], visit);
+    }
+}
+function traverseNode(node, visit) {
+    if (!node) {
+        return;
+    }
+    visit(node);
+    if (node.type === utils_1.NodeTypes.Resource) {
+        traverseNode(node.body, visit);
+    }
+    else if (node.type === utils_1.NodeTypes.Plural) {
+        traverseNodes(node.cases, visit);
+    }
+    else if (node.type === utils_1.NodeTypes.Message) {
+        traverseNodes(node.items, visit);
+    }
+    else if (node.type === utils_1.NodeTypes.Linked) {
+        const linked = node;
+        if (linked.modifier)
+            traverseNode(linked.modifier, visit);
+        traverseNode(linked.key, visit);
+    }
+}
+exports.traverseNode = traverseNode;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/message-compiler/utils.d.ts

@@ -0,0 +1,28 @@
+import type { RuleContext } from '../../types';
+import type { AST as JSONAST } from 'jsonc-eslint-parser';
+import type { AST as YAMLAST } from 'yaml-eslint-parser';
+export declare const NodeTypes: {
+    readonly Resource: 0;
+    readonly Plural: 1;
+    readonly Message: 2;
+    readonly Text: 3;
+    readonly Named: 4;
+    readonly List: 5;
+    readonly Linked: 6;
+    readonly LinkedKey: 7;
+    readonly LinkedModifier: 8;
+    readonly Literal: 9;
+};
+export type MessageSyntaxVersions = {
+    v9: boolean;
+    v10: boolean;
+    v11: boolean;
+    isNotSet: boolean;
+    reportIfMissingSetting: () => boolean;
+};
+export declare function getMessageSyntaxVersions(context: RuleContext): MessageSyntaxVersions;
+export declare function getReportIndex(node: JSONAST.JSONNode | YAMLAST.YAMLNode, stringOffset: number): number | null;
+export declare function getJSONStringOffset(code: string, stringOffset: number): number;
+export declare function getYAMLSingleQuotedStringOffset(code: string, stringOffset: number): number;
+export declare function getYAMLDoubleQuotedStringOffset(code: string, stringOffset: number): number;
+export declare function getYAMLPlainStringOffset(code: string, stringOffset: number): number;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/message-compiler/utils.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getYAMLPlainStringOffset = exports.getYAMLDoubleQuotedStringOffset = exports.getYAMLSingleQuotedStringOffset = exports.getJSONStringOffset = exports.getReportIndex = exports.getMessageSyntaxVersions = exports.NodeTypes = void 0;
+const semver_1 = require("semver");
+exports.NodeTypes = {
+    Resource: 0,
+    Plural: 1,
+    Message: 2,
+    Text: 3,
+    Named: 4,
+    List: 5,
+    Linked: 6,
+    LinkedKey: 7,
+    LinkedModifier: 8,
+    Literal: 9
+};
+const puttedSettingsError = new WeakSet();
+function getMessageSyntaxVersions(context) {
+    const { settings } = context;
+    const messageSyntaxVersion = settings['vue-i18n'] && settings['vue-i18n'].messageSyntaxVersion;
+    if (!messageSyntaxVersion) {
+        return {
+            v9: true,
+            v10: true,
+            v11: true,
+            isNotSet: true,
+            reportIfMissingSetting: () => {
+                if (!puttedSettingsError.has(context)) {
+                    const ruleName = context.id;
+                    context.report({
+                        loc: { line: 1, column: 0 },
+                        message: `If you want to use '${ruleName}' rule, you need to set 'messageSyntaxVersion' at 'settings'. See the 'eslint-plugin-vue-i18n' documentation`
+                    });
+                    puttedSettingsError.add(context);
+                }
+                return true;
+            }
+        };
+    }
+    const range = new semver_1.Range(messageSyntaxVersion);
+    const v9 = (0, semver_1.intersects)(range, '^9.0.0-0');
+    const v10 = (0, semver_1.intersects)(range, '^10.0.0-0');
+    const v11 = (0, semver_1.intersects)(range, '>=11.0.0-0');
+    if (!v9 && !v10 && !v11 && !puttedSettingsError.has(context)) {
+        context.report({
+            loc: { line: 1, column: 0 },
+            message: `Please specify 9 or higher for 'messageSyntaxVersion' at 'settings'.`
+        });
+        puttedSettingsError.add(context);
+    }
+    return {
+        v9,
+        v10,
+        v11,
+        isNotSet: false,
+        reportIfMissingSetting: () => false
+    };
+}
+exports.getMessageSyntaxVersions = getMessageSyntaxVersions;
+function getReportIndex(node, stringOffset) {
+    if (node.type === 'JSONLiteral' || node.type === 'JSONTemplateLiteral') {
+        const stringCode = node.type === 'JSONLiteral'
+            ? node.raw.slice(1, -1)
+            : node.quasis[0].value.raw;
+        return (node.range[0] +
+            1 +
+            getJSONStringOffset(stringCode, stringOffset));
+    }
+    if (node.type === 'YAMLScalar') {
+        if (node.style === 'single-quoted' || node.style === 'double-quoted') {
+            const stringCode = node.raw.slice(1, -1);
+            return (node.range[0] +
+                1 +
+                (node.style === 'single-quoted'
+                    ? getYAMLSingleQuotedStringOffset(stringCode, stringOffset)
+                    : getYAMLDoubleQuotedStringOffset(stringCode, stringOffset)));
+        }
+        if (node.style === 'plain') {
+            const stringCode = node.raw;
+            return node.range[0] + getYAMLPlainStringOffset(stringCode, stringOffset);
+        }
+    }
+    return null;
+}
+exports.getReportIndex = getReportIndex;
+function getJSONStringOffset(code, stringOffset) {
+    let offset = stringOffset;
+    let codeIndex = 0;
+    let char;
+    while ((char = code[codeIndex++]) && offset > 0) {
+        if (char === '\\') {
+            char = code[codeIndex++];
+            if (char === 'x') {
+                codeIndex += 2;
+            }
+            else if (char === 'u') {
+                char = code[codeIndex++];
+                if (char === '{') {
+                    let pointStr = '';
+                    while ((char = code[codeIndex++]) && char !== '}') {
+                        pointStr += char;
+                    }
+                    let point = parseInt(pointStr, 16);
+                    while (point > 0xffff) {
+                        offset--;
+                        point >>= 16;
+                    }
+                }
+                else {
+                    codeIndex += 3;
+                }
+            }
+            else if (char >= '0' && char <= '9') {
+                let octalStr = code.substr(codeIndex - 1, 3).match(/^[0-7]+/u)[0];
+                const octal = parseInt(octalStr, 8);
+                if (octal > 255) {
+                    octalStr = octalStr.slice(0, -1);
+                }
+                if (octalStr.length >= 2) {
+                    codeIndex += octalStr.length - 1;
+                }
+            }
+        }
+        offset--;
+    }
+    return Math.min(codeIndex - 1, code.length);
+}
+exports.getJSONStringOffset = getJSONStringOffset;
+function getYAMLSingleQuotedStringOffset(code, stringOffset) {
+    let offset = stringOffset;
+    let codeIndex = 0;
+    let char;
+    let lineFolding = 0;
+    while ((char = code[codeIndex++]) && offset > 0) {
+        if (char === "'" && code[codeIndex] === "'") {
+            codeIndex++;
+            lineFolding = 0;
+        }
+        else if (isSpaceOrEOL(char)) {
+            let nextCodeIndex = processMaybeLineFolding(code, codeIndex - 1);
+            if (nextCodeIndex != null) {
+                if (lineFolding === 0 && isEOL(code[nextCodeIndex])) {
+                    nextCodeIndex = processMaybeLineFolding(code, nextCodeIndex);
+                }
+                codeIndex = nextCodeIndex;
+                lineFolding++;
+            }
+            else {
+                lineFolding = 0;
+            }
+        }
+        else {
+            lineFolding = 0;
+        }
+        offset--;
+    }
+    return Math.min(codeIndex - 1, code.length);
+}
+exports.getYAMLSingleQuotedStringOffset = getYAMLSingleQuotedStringOffset;
+function getYAMLDoubleQuotedStringOffset(code, stringOffset) {
+    let offset = stringOffset;
+    let codeIndex = 0;
+    let char;
+    let lineFolding = 0;
+    while ((char = code[codeIndex++]) && offset > 0) {
+        if (char === '\\') {
+            char = code[codeIndex++];
+            if (char === 'x') {
+                codeIndex += 2;
+            }
+            else if (char === 'u') {
+                codeIndex += 4;
+            }
+            else if (char === 'U') {
+                if (code.substr(codeIndex, 4) !== '0000') {
+                    offset--;
+                }
+                codeIndex += 8;
+            }
+            else if (isEOL(char)) {
+                const nextCodeIndex = processMaybeLineFolding(code, codeIndex - 1);
+                if (nextCodeIndex != null) {
+                    codeIndex = nextCodeIndex + 1;
+                    if (code[nextCodeIndex] === '\\') {
+                        codeIndex--;
+                        lineFolding = 0;
+                        continue;
+                    }
+                }
+            }
+            lineFolding = 0;
+        }
+        else if (isSpaceOrEOL(char)) {
+            let nextCodeIndex = processMaybeLineFolding(code, codeIndex - 1);
+            if (nextCodeIndex != null) {
+                if (lineFolding === 0 && isEOL(code[nextCodeIndex])) {
+                    nextCodeIndex = processMaybeLineFolding(code, nextCodeIndex);
+                }
+                codeIndex = nextCodeIndex;
+                lineFolding++;
+            }
+            else {
+                lineFolding = 0;
+            }
+        }
+        else {
+            lineFolding = 0;
+        }
+        offset--;
+    }
+    return Math.min(codeIndex - 1, code.length);
+}
+exports.getYAMLDoubleQuotedStringOffset = getYAMLDoubleQuotedStringOffset;
+function getYAMLPlainStringOffset(code, stringOffset) {
+    let offset = stringOffset;
+    let codeIndex = 0;
+    let char;
+    let lineFolding = 0;
+    while ((char = code[codeIndex++]) && offset > 0) {
+        if (isSpaceOrEOL(char)) {
+            let nextCodeIndex = processMaybeLineFolding(code, codeIndex - 1);
+            if (nextCodeIndex != null) {
+                if (lineFolding === 0 && isEOL(code[nextCodeIndex])) {
+                    nextCodeIndex = processMaybeLineFolding(code, nextCodeIndex);
+                }
+                codeIndex = nextCodeIndex;
+                lineFolding++;
+            }
+            else {
+                lineFolding = 0;
+            }
+        }
+        else {
+            lineFolding = 0;
+        }
+        offset--;
+    }
+    return Math.min(codeIndex - 1, code.length);
+}
+exports.getYAMLPlainStringOffset = getYAMLPlainStringOffset;
+function isSpace(char) {
+    return char === ' ' || char === '\t';
+}
+function isSpaceOrEOL(char) {
+    return isSpace(char) || isEOL(char);
+}
+function isEOL(char) {
+    return char === '\n' || char === '\r';
+}
+function processMaybeLineFolding(code, spaceIndex) {
+    let codeIndex = spaceIndex;
+    let char;
+    let hasNewline = false;
+    while ((char = code[codeIndex++])) {
+        if (isEOL(char)) {
+            if (hasNewline) {
+                return codeIndex - 1;
+            }
+            if (char === '\r' && code[codeIndex] === '\n') {
+                codeIndex++;
+            }
+            hasNewline = true;
+        }
+        else if (!isSpace(char)) {
+            if (hasNewline) {
+                return codeIndex - 1;
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    if (hasNewline) {
+        return codeIndex - 1;
+    }
+    else {
+        return null;
+    }
+}

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/parser-config-resolver/build-parser-using-flat-config.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from '.';
+export declare function buildParserUsingFlatConfig(cwd: string): Parser;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/parser-config-resolver/build-parser-using-flat-config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildParserUsingFlatConfig = void 0;
+const synckit_1 = require("synckit");
+const getSync = (0, synckit_1.createSyncFn)(require.resolve('./worker'));
+function buildParserUsingFlatConfig(cwd) {
+    return (filePath) => {
+        return getSync(cwd, filePath);
+    };
+}
+exports.buildParserUsingFlatConfig = buildParserUsingFlatConfig;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/parser-config-resolver/build-parser-using-legacy-config.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from '.';
+export declare function buildParserUsingLegacyConfig(cwd: string): Parser;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/parser-config-resolver/build-parser-using-legacy-config.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildParserUsingLegacyConfig = void 0;
+const eslintrc_1 = require("@eslint/eslintrc");
+const path_1 = __importDefault(require("path"));
+const parse_by_parser_1 = require("./parse-by-parser");
+const { CascadingConfigArrayFactory } = eslintrc_1.Legacy;
+function buildParserUsingLegacyConfig(cwd) {
+    const configArrayFactory = new CascadingConfigArrayFactory({
+        additionalPluginPool: new Map([
+            ['@intlify/vue-i18n', require('../../index')]
+        ]),
+        cwd,
+        getEslintRecommendedConfig() {
+            return {};
+        },
+        getEslintAllConfig() {
+            return {};
+        }
+    });
+    function getConfigForFile(filePath) {
+        const absolutePath = path_1.default.resolve(cwd, filePath);
+        return configArrayFactory
+            .getConfigArrayForFile(absolutePath)
+            .extractConfig(absolutePath)
+            .toCompatibleObjectAsConfigFileContent();
+    }
+    return (filePath) => {
+        const config = getConfigForFile(filePath);
+        const parserOptions = Object.assign({}, config.parserOptions, {
+            loc: true,
+            range: true,
+            raw: true,
+            tokens: true,
+            comment: true,
+            eslintVisitorKeys: true,
+            eslintScopeManager: true,
+            filePath
+        });
+        return (0, parse_by_parser_1.parseByParser)(filePath, config.parser, parserOptions);
+    };
+}
+exports.buildParserUsingLegacyConfig = buildParserUsingLegacyConfig;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/parser-config-resolver/index.d.ts

@@ -0,0 +1,4 @@
+import type { AST as VAST } from 'vue-eslint-parser';
+export type ParseResult = Pick<VAST.ESLintExtendedProgram, 'ast' | 'visitorKeys'> | null;
+export type Parser = (filePath: string) => ParseResult;
+export declare function buildParserFromConfig(cwd: string): Parser;