@alexlit/lint-kit 167.2.0 → 167.4.0

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

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usedKeysCache = exports.collectKeysFromAST = void 0;
+const vue_eslint_parser_1 = require("vue-eslint-parser");
+const path_1 = require("path");
+const glob_utils_1 = require("./glob-utils");
+const resource_loader_1 = require("./resource-loader");
+const cache_loader_1 = require("./cache-loader");
+const cache_function_1 = require("./cache-function");
+const debug_1 = __importDefault(require("debug"));
+const get_cwd_1 = require("./get-cwd");
+const index_1 = require("./index");
+const parser_config_resolver_1 = require("./parser-config-resolver");
+const debug = (0, debug_1.default)('eslint-plugin-vue-i18n:collect-keys');
+function getKeyFromCallExpression(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 null;
+    }
+    const [keyNode] = node.arguments;
+    if (!(0, index_1.isStaticLiteral)(keyNode)) {
+        return null;
+    }
+    return (0, index_1.getStaticLiteralValue)(keyNode);
+}
+function getKeyFromVDirective(node) {
+    if (node.value &&
+        node.value.type === 'VExpressionContainer' &&
+        (0, index_1.isStaticLiteral)(node.value.expression)) {
+        return (0, index_1.getStaticLiteralValue)(node.value.expression);
+    }
+    else {
+        return null;
+    }
+}
+function getKeyFromI18nComponent(node) {
+    if (node.value && node.value.type === 'VLiteral') {
+        return node.value.value;
+    }
+    else {
+        return null;
+    }
+}
+function collectKeysFromText(filename, parser) {
+    const effectiveFilename = filename || '<text>';
+    debug(`collectKeysFromFile ${effectiveFilename}`);
+    try {
+        const parseResult = parser(filename);
+        if (!parseResult) {
+            return [];
+        }
+        return collectKeysFromAST(parseResult.ast, parseResult.visitorKeys);
+    }
+    catch (_e) {
+        return [];
+    }
+}
+function collectKeyResourcesFromFiles(fileNames, cwd) {
+    debug('collectKeysFromFiles', fileNames);
+    const parser = (0, parser_config_resolver_1.buildParserFromConfig)(cwd);
+    const results = [];
+    for (const filename of fileNames) {
+        debug(`Processing file ... ${filename}`);
+        results.push(new resource_loader_1.ResourceLoader((0, path_1.resolve)(filename), () => {
+            return collectKeysFromText(filename, parser);
+        }));
+    }
+    return results;
+}
+function collectKeysFromAST(node, visitorKeys) {
+    debug('collectKeysFromAST');
+    const results = new Set();
+    function enterNode(node) {
+        if (node.type === 'VAttribute') {
+            if (node.directive) {
+                if (node.key.name.name === 't' ||
+                    node.key.name === 't') {
+                    debug("call VAttribute[directive=true][key.name.name='t'] handling ...");
+                    const key = getKeyFromVDirective(node);
+                    if (key) {
+                        results.add(String(key));
+                    }
+                }
+            }
+            else {
+                if ((node.key.name === 'path' &&
+                    (node.parent.parent.name === 'i18n' ||
+                        node.parent.parent.name === 'i18n-t' ||
+                        node.parent.parent.rawName === 'I18nT')) ||
+                    (node.key.name === 'keypath' &&
+                        (node.parent.parent.name === 'i18n-t' ||
+                            node.parent.parent.rawName === 'I18nT'))) {
+                    debug("call VElement:matches([name=i18n], [name=i18n-t], [name=I18nT]) > VStartTag > VAttribute[key.name='path'] handling ...");
+                    const key = getKeyFromI18nComponent(node);
+                    if (key) {
+                        results.add(key);
+                    }
+                }
+            }
+        }
+        else if (node.type === 'CallExpression') {
+            debug('CallExpression handling ...');
+            const key = getKeyFromCallExpression(node);
+            if (key) {
+                results.add(String(key));
+            }
+        }
+    }
+    if (node.templateBody) {
+        vue_eslint_parser_1.AST.traverseNodes(node.templateBody, {
+            enterNode,
+            leaveNode() {
+            }
+        });
+    }
+    vue_eslint_parser_1.AST.traverseNodes(node, {
+        visitorKeys,
+        enterNode,
+        leaveNode() {
+        }
+    });
+    return [...results];
+}
+exports.collectKeysFromAST = collectKeysFromAST;
+class UsedKeysCache {
+    constructor() {
+        this._targetFilesLoader = new cache_loader_1.CacheLoader((cwd, files, extensions) => {
+            return (0, glob_utils_1.listFilesToProcess)(files, { cwd, extensions })
+                .filter(f => !f.ignored && extensions.includes((0, path_1.extname)(f.filename)))
+                .map(f => f.filename);
+        });
+        this._collectKeyResourcesFromFiles = (0, cache_function_1.defineCacheFunction)((fileNames, cwd) => {
+            return collectKeyResourcesFromFiles(fileNames, cwd);
+        });
+    }
+    collectKeysFromFiles(files, extensions, context) {
+        const result = new Set();
+        for (const resource of this._getKeyResources(context, files, extensions)) {
+            for (const key of resource.getResource()) {
+                result.add(key);
+            }
+        }
+        return [...result];
+    }
+    _getKeyResources(context, files, extensions) {
+        const cwd = (0, get_cwd_1.getCwd)(context);
+        const fileNames = this._targetFilesLoader.get(cwd, files, extensions, cwd);
+        return this._collectKeyResourcesFromFiles(fileNames, cwd);
+    }
+}
+exports.usedKeysCache = new UsedKeysCache();

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

@@ -0,0 +1,2 @@
+import type { I18nLocaleMessageDictionary, RuleContext } from '../types';
+export declare function collectLinkedKeys(object: I18nLocaleMessageDictionary, context: RuleContext): string[];

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectLinkedKeys = void 0;
+const traverser_1 = require("./message-compiler/traverser");
+const parser_1 = require("./message-compiler/parser");
+const parser_v9_1 = require("./message-compiler/parser-v9");
+const utils_1 = require("./message-compiler/utils");
+const utils_2 = require("./message-compiler/utils");
+function* extractUsedKeysFromLinks(object, messageSyntaxVersions) {
+    for (const value of Object.values(object)) {
+        if (!value) {
+            continue;
+        }
+        if (typeof value === 'object') {
+            yield* extractUsedKeysFromLinks(value, messageSyntaxVersions);
+        }
+        else if (typeof value === 'string') {
+            if (messageSyntaxVersions.v10 || messageSyntaxVersions.v11) {
+                yield* extractUsedKeysFromAST((0, parser_1.parse)(value).ast);
+            }
+            if (messageSyntaxVersions.v9) {
+                yield* extractUsedKeysFromAST((0, parser_v9_1.parse)(value).ast);
+            }
+        }
+    }
+}
+function collectLinkedKeys(object, context) {
+    return [
+        ...new Set(extractUsedKeysFromLinks(object, (0, utils_2.getMessageSyntaxVersions)(context)))
+    ].filter(s => !!s);
+}
+exports.collectLinkedKeys = collectLinkedKeys;
+function extractUsedKeysFromAST(ast) {
+    const keys = new Set();
+    (0, traverser_1.traverseNode)(ast, node => {
+        if (node.type === utils_1.NodeTypes.Linked) {
+            if (node.key.type === utils_1.NodeTypes.LinkedKey) {
+                keys.add(node.key.value);
+            }
+            else if (node.key.type === utils_1.NodeTypes.Literal && node.key.value) {
+                keys.add(node.key.value);
+            }
+            else if (node.key.type === utils_1.NodeTypes.List) {
+                keys.add(String(node.key.index));
+            }
+        }
+    });
+    return keys;
+}

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

@@ -0,0 +1,3 @@
+import type { RuleContext, SourceCode } from '../types';
+export declare function getFilename(context: RuleContext): string;
+export declare function getSourceCode(context: RuleContext): SourceCode;

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

@@ -0,0 +1,35 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourceCode = exports.getFilename = void 0;
+const compat = __importStar(require("eslint-compat-utils"));
+function getFilename(context) {
+    return compat.getFilename(context);
+}
+exports.getFilename = getFilename;
+function getSourceCode(context) {
+    return compat.getSourceCode(context);
+}
+exports.getSourceCode = getSourceCode;

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

@@ -0,0 +1,6 @@
+export declare let CACHE_LOADER: number;
+export declare let MTIME_MS_CHECK: number;
+export declare function setTimeouts(times: {
+    CACHE_LOADER: number;
+    MTIME_MS_CHECK: number;
+}): void;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setTimeouts = exports.MTIME_MS_CHECK = exports.CACHE_LOADER = void 0;
+exports.CACHE_LOADER = 1000;
+exports.MTIME_MS_CHECK = 300;
+function setTimeouts(times) {
+    exports.CACHE_LOADER = times.CACHE_LOADER;
+    exports.MTIME_MS_CHECK = times.MTIME_MS_CHECK;
+}
+exports.setTimeouts = setTimeouts;

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

@@ -0,0 +1,2 @@
+import type { RuleContext } from '../types';
+export declare function getCwd(context: RuleContext): string;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCwd = void 0;
+const eslint_compat_utils_1 = require("eslint-compat-utils");
+function getCwd(context) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = context.settings) === null || _a === void 0 ? void 0 : _a['vue-i18n']) === null || _b === void 0 ? void 0 : _b.cwd) !== null && _c !== void 0 ? _c : (0, eslint_compat_utils_1.getCwd)(context);
+}
+exports.getCwd = getCwd;

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

@@ -0,0 +1,15 @@
+export declare function resolveFileGlobPatterns(patterns: string[], options: {
+    cwd?: string;
+    extensions?: string[];
+    globInputPaths?: boolean;
+}): string[];
+export declare function listFilesToProcess(globPatterns: string[], providedOptions: {
+    cwd?: string;
+    extensions?: string[];
+    globInputPaths?: boolean;
+    ignore?: boolean;
+    dotfiles?: boolean;
+}): {
+    filename: string;
+    ignored: boolean;
+}[];

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

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listFilesToProcess = exports.resolveFileGlobPatterns = void 0;
+const lodash_1 = require("lodash");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const glob_1 = require("glob");
+const path_utils_1 = require("./path-utils");
+const ignored_paths_1 = require("./ignored-paths");
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('eslint-plugin-vue-i18n:glob-utils');
+function directoryExists(resolvedPath) {
+    return (0, fs_1.existsSync)(resolvedPath) && (0, fs_1.statSync)(resolvedPath).isDirectory();
+}
+function processPath(options) {
+    const cwd = (options && options.cwd) || process.cwd();
+    let extensions = (options && options.extensions) || ['.js'];
+    extensions = extensions.map(ext => ext.replace(/^\./, ''));
+    let suffix = '/**';
+    if (extensions.length === 1) {
+        suffix += `/*.${extensions[0]}`;
+    }
+    else {
+        suffix += `/*.{${extensions.join(',')}}`;
+    }
+    return function (pathname) {
+        let newPath = pathname;
+        const resolvedPath = (0, path_1.resolve)(cwd, pathname);
+        if (directoryExists(resolvedPath)) {
+            newPath = pathname.replace(/[/\\]$/, '') + suffix;
+        }
+        return (0, path_utils_1.convertPathToPosix)(newPath);
+    };
+}
+class NoFilesFoundError extends Error {
+    constructor(pattern) {
+        super(`No files matching '${pattern}' were found.`);
+        this.messageTemplate = 'file-not-found';
+        this.messageData = { pattern };
+    }
+}
+class AllFilesIgnoredError extends Error {
+    constructor(pattern) {
+        super(`All files matched by '${pattern}' are ignored.`);
+        this.messageTemplate = 'all-files-ignored';
+        this.messageData = { pattern };
+    }
+}
+const NORMAL_LINT = {};
+const SILENTLY_IGNORE = {};
+const IGNORE_AND_WARN = {};
+function testFileAgainstIgnorePatterns(filename, options, isDirectPath, ignoredPaths) {
+    const shouldProcessCustomIgnores = options.ignore !== false;
+    const shouldLintIgnoredDirectPaths = options.ignore === false;
+    const fileMatchesIgnorePatterns = ignoredPaths.contains(filename, 'default') ||
+        (shouldProcessCustomIgnores && ignoredPaths.contains(filename, 'custom'));
+    if (fileMatchesIgnorePatterns &&
+        isDirectPath &&
+        !shouldLintIgnoredDirectPaths) {
+        return IGNORE_AND_WARN;
+    }
+    if (!fileMatchesIgnorePatterns ||
+        (isDirectPath && shouldLintIgnoredDirectPaths)) {
+        return NORMAL_LINT;
+    }
+    return SILENTLY_IGNORE;
+}
+function resolveFileGlobPatterns(patterns, options) {
+    if (options.globInputPaths === false) {
+        return patterns;
+    }
+    const processPathExtensions = processPath(options);
+    return patterns.map(processPathExtensions);
+}
+exports.resolveFileGlobPatterns = resolveFileGlobPatterns;
+const dotfilesPattern = /(?:(?:^\.)|(?:[/\\]\.))[^/\\.].*/;
+function listFilesToProcess(globPatterns, providedOptions) {
+    const options = providedOptions || { ignore: true };
+    const cwd = options.cwd || process.cwd();
+    const getIgnorePaths = (optionsObj) => new ignored_paths_1.IgnoredPaths(optionsObj);
+    const resolvedGlobPatterns = resolveFileGlobPatterns(globPatterns, options);
+    debug('Creating list of files to process.');
+    const resolvedPathsByGlobPattern = resolvedGlobPatterns.map(pattern => {
+        const file = (0, path_1.resolve)(cwd, pattern);
+        if (options.globInputPaths === false ||
+            ((0, fs_1.existsSync)(file) && (0, fs_1.statSync)(file).isFile())) {
+            const ignoredPaths = getIgnorePaths(options);
+            const fullPath = options.globInputPaths === false ? file : (0, fs_1.realpathSync)(file);
+            return [
+                {
+                    filename: fullPath,
+                    behavior: testFileAgainstIgnorePatterns(fullPath, options, true, ignoredPaths)
+                }
+            ];
+        }
+        const globIncludesDotfiles = dotfilesPattern.test(pattern);
+        let newOptions = options;
+        if (!options.dotfiles) {
+            newOptions = Object.assign({}, options, {
+                dotfiles: globIncludesDotfiles
+            });
+        }
+        const ignoredPaths = getIgnorePaths(newOptions);
+        const shouldIgnore = ignoredPaths.getIgnoredFoldersGlobChecker();
+        const globOptions = {
+            nodir: true,
+            dot: true,
+            cwd,
+            ignore: { ignored: shouldIgnore }
+        };
+        return (0, glob_1.globSync)(pattern, globOptions).map(globMatch => {
+            if (typeof globMatch !== 'string')
+                return;
+            const relativePath = (0, path_1.resolve)(cwd, globMatch);
+            return {
+                filename: relativePath,
+                behavior: testFileAgainstIgnorePatterns(relativePath, options, false, ignoredPaths)
+            };
+        });
+    });
+    const allPathDescriptors = resolvedPathsByGlobPattern.reduce((pathsForAllGlobs, pathsForCurrentGlob, index) => {
+        if (pathsForCurrentGlob.every(pathDescriptor => (pathDescriptor === null || pathDescriptor === void 0 ? void 0 : pathDescriptor.behavior) === SILENTLY_IGNORE)) {
+            throw new (pathsForCurrentGlob.length ? AllFilesIgnoredError : NoFilesFoundError)(globPatterns[index]);
+        }
+        pathsForCurrentGlob.forEach(pathDescriptor => {
+            switch (pathDescriptor === null || pathDescriptor === void 0 ? void 0 : pathDescriptor.behavior) {
+                case NORMAL_LINT:
+                    pathsForAllGlobs.push({
+                        filename: pathDescriptor.filename,
+                        ignored: false
+                    });
+                    break;
+                case IGNORE_AND_WARN:
+                    pathsForAllGlobs.push({
+                        filename: pathDescriptor.filename,
+                        ignored: true
+                    });
+                    break;
+                case SILENTLY_IGNORE:
+                    break;
+                default:
+                    throw new Error(`Unexpected file behavior for ${pathDescriptor === null || pathDescriptor === void 0 ? void 0 : pathDescriptor.filename}`);
+            }
+        });
+        return pathsForAllGlobs;
+    }, []);
+    const ret = (0, lodash_1.uniqBy)(allPathDescriptors, pathDescriptor => pathDescriptor.filename);
+    debug(ret);
+    return ret;
+}
+exports.listFilesToProcess = listFilesToProcess;

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

@@ -0,0 +1,43 @@
+import type { Ignore } from 'ignore';
+import type { Path } from 'path-scurry';
+export declare class IgnoredPaths {
+    cache: {
+        [key: string]: string[] | undefined;
+    };
+    defaultPatterns: string[];
+    ignoreFileDir: string;
+    options: {
+        dotfiles: boolean;
+        cwd: string;
+        patterns?: string[];
+        ignore?: boolean;
+        ignorePath?: string;
+        ignorePattern?: string;
+    };
+    private _baseDir;
+    ig: {
+        custom: Ignore & {
+            ignoreFiles: string[];
+        };
+        default: Ignore & {
+            ignoreFiles: string[];
+        };
+    };
+    constructor(providedOptions: {
+        dotfiles?: boolean | undefined;
+        cwd?: string | undefined;
+        patterns?: string[];
+        ignore?: boolean;
+        ignorePath?: string;
+        ignorePattern?: string;
+    });
+    addPatternRelativeToCwd(ig: Ignore, pattern: string): void;
+    addPatternRelativeToIgnoreFile(ig: Ignore, pattern: string): void;
+    getBaseDir(): string;
+    readIgnoreFile(filePath: string): string[];
+    addIgnoreFile(ig: Ignore & {
+        ignoreFiles: string[];
+    }, filePath: string): void;
+    contains(filepath: string, category?: 'custom' | 'default'): boolean;
+    getIgnoredFoldersGlobChecker(): (absolutePath: Path) => boolean;
+}