@alexlit/lint-kit 167.2.0 → 167.4.0

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildParserFromConfig = void 0;
+const should_use_flat_config_1 = require("./should-use-flat-config");
+const build_parser_using_legacy_config_1 = require("./build-parser-using-legacy-config");
+const build_parser_using_flat_config_1 = require("./build-parser-using-flat-config");
+const parsers = {};
+function buildParserFromConfig(cwd) {
+    const parser = parsers[cwd];
+    if (parser) {
+        return parser;
+    }
+    if ((0, should_use_flat_config_1.shouldUseFlatConfig)(cwd)) {
+        return (parsers[cwd] = (0, build_parser_using_flat_config_1.buildParserUsingFlatConfig)(cwd));
+    }
+    return (parsers[cwd] = (0, build_parser_using_legacy_config_1.buildParserUsingLegacyConfig)(cwd));
+}
+exports.buildParserFromConfig = buildParserFromConfig;

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

@@ -0,0 +1,3 @@
+import type { Linter } from 'eslint';
+import type { ParseResult } from '.';
+export declare function parseByParser(filePath: string, parserDefine: Linter.ParserModule | string | undefined, parserOptions: unknown): ParseResult;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/parser-config-resolver/parse-by-parser.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseByParser = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const vue_eslint_parser_1 = require("vue-eslint-parser");
+function parseByParser(filePath, parserDefine, parserOptions) {
+    const parser = getParser(parserDefine, filePath);
+    try {
+        const text = (0, fs_1.readFileSync)(path_1.default.resolve(filePath), 'utf8');
+        const parseResult = 'parseForESLint' in parser && typeof parser.parseForESLint === 'function'
+            ? parser.parseForESLint(text, parserOptions)
+            :
+                { ast: parser.parse(text, parserOptions) };
+        return parseResult;
+    }
+    catch (_e) {
+        return null;
+    }
+}
+exports.parseByParser = parseByParser;
+function getParser(parser, filePath) {
+    if (parser) {
+        if (typeof parser === 'string') {
+            try {
+                return require(parser);
+            }
+            catch (_e) {
+            }
+        }
+        else {
+            return parser;
+        }
+    }
+    if (filePath.endsWith('.vue')) {
+        return { parseForESLint: vue_eslint_parser_1.parseForESLint };
+    }
+    return require('espree');
+}

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

@@ -0,0 +1,2 @@
+export declare function shouldUseFlatConfig(cwd: string): boolean;
+export declare function findFlatConfigFile(cwd: string): string | null;

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

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFlatConfigFile = exports.shouldUseFlatConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const FLAT_CONFIG_FILENAMES = [
+    'eslint.config.js',
+    'eslint.config.mjs',
+    'eslint.config.cjs',
+    'eslint.config.ts',
+    'eslint.config.mts',
+    'eslint.config.cts'
+];
+function shouldUseFlatConfig(cwd) {
+    switch (process.env.ESLINT_USE_FLAT_CONFIG) {
+        case 'true':
+            return true;
+        case 'false':
+            return false;
+        default:
+            return Boolean(findFlatConfigFile(cwd));
+    }
+}
+exports.shouldUseFlatConfig = shouldUseFlatConfig;
+function findFlatConfigFile(cwd) {
+    return findUp(FLAT_CONFIG_FILENAMES, { cwd });
+}
+exports.findFlatConfigFile = findFlatConfigFile;
+function findUp(names, options) {
+    let directory = path_1.default.resolve(options.cwd);
+    const { root } = path_1.default.parse(directory);
+    const stopAt = path_1.default.resolve(directory, root);
+    while (true) {
+        for (const name of names) {
+            const target = path_1.default.resolve(directory, name);
+            const stat = fs_1.default.existsSync(target)
+                ? fs_1.default.statSync(target, {
+                    throwIfNoEntry: false
+                })
+                : null;
+            if (stat === null || stat === void 0 ? void 0 : stat.isFile()) {
+                return target;
+            }
+        }
+        if (directory === stopAt) {
+            break;
+        }
+        directory = path_1.default.dirname(directory);
+    }
+    return null;
+}

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

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

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const synckit_1 = require("synckit");
+const eslint_1 = require("eslint-compat-utils/eslint");
+const parse_by_parser_1 = require("./parse-by-parser");
+const ESLint = (0, eslint_1.getESLint)();
+(0, synckit_1.runAsWorker)(async (cwd, filePath) => {
+    const eslint = new ESLint({ cwd });
+    const config = await eslint.calculateConfigForFile(filePath);
+    const languageOptions = config.languageOptions || {};
+    const parserOptions = Object.assign({
+        sourceType: languageOptions.sourceType || 'module',
+        ecmaVersion: languageOptions.ecmaVersion || 'latest'
+    }, languageOptions.parserOptions, {
+        loc: true,
+        range: true,
+        raw: true,
+        tokens: true,
+        comment: true,
+        eslintVisitorKeys: true,
+        eslintScopeManager: true,
+        filePath
+    });
+    const result = (0, parse_by_parser_1.parseByParser)(filePath, languageOptions.parser, parserOptions);
+    if (!result) {
+        return null;
+    }
+    return {
+        ast: result.ast,
+        visitorKeys: result === null || result === void 0 ? void 0 : result.visitorKeys
+    };
+});

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

@@ -0,0 +1,4 @@
+import type { AST as VAST } from 'vue-eslint-parser';
+import type { I18nLocaleMessageDictionary } from '../../types';
+export declare function parseJsonValuesInI18nBlock(i18nBlock: VAST.VElement): I18nLocaleMessageDictionary | null;
+export declare function parseYamlValuesInI18nBlock(i18nBlock: VAST.VElement): I18nLocaleMessageDictionary | null;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseYamlValuesInI18nBlock = exports.parseJsonValuesInI18nBlock = void 0;
+const json5_1 = require("json5");
+const js_yaml_1 = require("js-yaml");
+function hasEndTag(element) {
+    return !!element.endTag;
+}
+function parseValuesInI18nBlock(i18nBlock, parse) {
+    if (!hasEndTag(i18nBlock)) {
+        return null;
+    }
+    const text = i18nBlock.children[0];
+    const sourceString = text != null && text.type === 'VText' ? text.value : '';
+    if (!sourceString.trim()) {
+        return null;
+    }
+    try {
+        return parse(sourceString);
+    }
+    catch (e) {
+        return null;
+    }
+}
+function parseJsonValuesInI18nBlock(i18nBlock) {
+    return parseValuesInI18nBlock(i18nBlock, code => (0, json5_1.parse)(code));
+}
+exports.parseJsonValuesInI18nBlock = parseJsonValuesInI18nBlock;
+function parseYamlValuesInI18nBlock(i18nBlock) {
+    return parseValuesInI18nBlock(i18nBlock, code => (0, js_yaml_1.load)(code));
+}
+exports.parseYamlValuesInI18nBlock = parseYamlValuesInI18nBlock;

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

@@ -0,0 +1,2 @@
+export declare function convertPathToPosix(filepath: string): string;
+export declare function getRelativePath(filepath: string, baseDir: string): string;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelativePath = exports.convertPathToPosix = void 0;
+const path_1 = require("path");
+function convertPathToPosix(filepath) {
+    const normalizedFilepath = (0, path_1.normalize)(filepath);
+    const posixFilepath = normalizedFilepath.replace(/\\/g, '/');
+    return posixFilepath;
+}
+exports.convertPathToPosix = convertPathToPosix;
+function getRelativePath(filepath, baseDir) {
+    const absolutePath = (0, path_1.isAbsolute)(filepath) ? filepath : (0, path_1.resolve)(filepath);
+    if (baseDir) {
+        if (!(0, path_1.isAbsolute)(baseDir)) {
+            throw new Error(`baseDir should be an absolute path: ${baseDir}`);
+        }
+        return (0, path_1.relative)(baseDir, absolutePath);
+    }
+    return absolutePath.replace(/^\//, '');
+}
+exports.getRelativePath = getRelativePath;

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

@@ -0,0 +1 @@
+export declare function toRegExp(str: string): RegExp;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRegExp = void 0;
+const RE_REGEXP_CHAR = /[\\^$.*+?()[\]{}|]/gu;
+const RE_REGEXP_STR = /^\/(.+)\/(.*)$/u;
+function toRegExp(str) {
+    const parts = RE_REGEXP_STR.exec(str);
+    if (parts) {
+        return new RegExp(parts[1], parts[2]);
+    }
+    return new RegExp(`^${escape(str)}$`);
+}
+exports.toRegExp = toRegExp;
+function escape(str) {
+    return str && str.replace(RE_REGEXP_CHAR, '\\$&');
+}

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

@@ -0,0 +1,10 @@
+export type LoadResource<R> = (filename: string) => R;
+export declare class ResourceLoader<R> {
+    private filename;
+    private loader;
+    private _resource;
+    private _mtimeLoader;
+    private _mtimeMs;
+    constructor(filename: string, loader: LoadResource<R>, mtimeCheckTimeout?: number | (() => number));
+    getResource(): R;
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceLoader = void 0;
+const fs_1 = require("fs");
+const cache_loader_1 = require("./cache-loader");
+const default_timeouts_1 = require("./default-timeouts");
+class ResourceLoader {
+    constructor(filename, loader, mtimeCheckTimeout = () => default_timeouts_1.MTIME_MS_CHECK) {
+        this._mtimeMs = 0;
+        this.filename = filename;
+        this.loader = loader;
+        this._resource = null;
+        this._mtimeLoader = new cache_loader_1.CacheLoader(() => {
+            try {
+                const stat = (0, fs_1.statSync)(this.filename);
+                return stat.mtimeMs;
+            }
+            catch (_e) {
+            }
+            return this._mtimeMs || 0;
+        }, mtimeCheckTimeout);
+    }
+    getResource() {
+        const mtimeMs = this._mtimeLoader.get();
+        if (this._resource && this._mtimeMs >= mtimeMs) {
+            return this._resource;
+        }
+        this._mtimeMs = mtimeMs;
+        return (this._resource = this.loader(this.filename));
+    }
+}
+exports.ResourceLoader = ResourceLoader;

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

@@ -0,0 +1,9 @@
+import type { RuleModule } from '../types';
+import type { AST as JSONAST } from 'jsonc-eslint-parser';
+import type { AST as YAMLAST } from 'yaml-eslint-parser';
+import type { CustomBlockVisitorFactory } from '../types/vue-parser-services';
+export type GetReportOffset = (offset: number) => number | null;
+export type VerifyMessage = (message: string, reportNode: JSONAST.JSONStringLiteral | YAMLAST.YAMLScalar, getReportOffset: GetReportOffset) => void;
+export declare function createRule(module: RuleModule): RuleModule;
+export declare function defineCreateVisitorForJson(verifyMessage: VerifyMessage): CustomBlockVisitorFactory;
+export declare function defineCreateVisitorForYaml(verifyMessage: VerifyMessage): CustomBlockVisitorFactory;

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineCreateVisitorForYaml = exports.defineCreateVisitorForJson = exports.createRule = void 0;
+const utils_1 = require("../utils/message-compiler/utils");
+function createRule(module) {
+    return module;
+}
+exports.createRule = createRule;
+function defineCreateVisitorForJson(verifyMessage) {
+    return function () {
+        function verifyExpression(node) {
+            if (node.type !== 'JSONLiteral' || typeof node.value !== 'string') {
+                return;
+            }
+            verifyMessage(node.value, node, offset => (0, utils_1.getReportIndex)(node, offset));
+        }
+        return {
+            JSONProperty(node) {
+                verifyExpression(node.value);
+            },
+            JSONArrayExpression(node) {
+                for (const element of node.elements) {
+                    if (element)
+                        verifyExpression(element);
+                }
+            }
+        };
+    };
+}
+exports.defineCreateVisitorForJson = defineCreateVisitorForJson;
+function defineCreateVisitorForYaml(verifyMessage) {
+    return function () {
+        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) {
+            const valueNode = node.type === 'YAMLWithMeta' ? node.value : node;
+            if (!valueNode ||
+                valueNode.type !== 'YAMLScalar' ||
+                typeof valueNode.value !== 'string') {
+                return;
+            }
+            verifyMessage(valueNode.value, valueNode, offset => (0, utils_1.getReportIndex)(valueNode, offset));
+        }
+        return {
+            YAMLPair(node) {
+                if (withinKey(node)) {
+                    return;
+                }
+                if (node.key != null) {
+                    yamlKeyNodes.add(node.key);
+                }
+                if (node.value)
+                    verifyContent(node.value);
+            },
+            YAMLSequence(node) {
+                if (withinKey(node)) {
+                    return;
+                }
+                for (const entry of node.entries) {
+                    if (entry)
+                        verifyContent(entry);
+                }
+            }
+        };
+    };
+}
+exports.defineCreateVisitorForYaml = defineCreateVisitorForYaml;