xo 0.52.2 → 0.52.3

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ts-eslint/ESLint.d.ts

@@ -0,0 +1,376 @@
+import { Linter } from './Linter';
+declare class ESLintBase {
+    /**
+     * Creates a new instance of the main ESLint API.
+     * @param options The options for this instance.
+     */
+    constructor(options?: ESLint.ESLintOptions);
+    /**
+     * This method calculates the configuration for a given file, which can be useful for debugging purposes.
+     * - It resolves and merges extends and overrides settings into the top level configuration.
+     * - It resolves the parser setting to absolute paths.
+     * - It normalizes the plugins setting to align short names. (e.g., eslint-plugin-foo → foo)
+     * - It adds the processor setting if a legacy file extension processor is matched.
+     * - It doesn't interpret the env setting to the globals and parserOptions settings, so the result object contains
+     *   the env setting as is.
+     * @param filePath The path to the file whose configuration you would like to calculate. Directory paths are forbidden
+     *                 because ESLint cannot handle the overrides setting.
+     * @returns The promise that will be fulfilled with a configuration object.
+     */
+    calculateConfigForFile(filePath: string): Promise<Linter.Config>;
+    /**
+     * This method checks if a given file is ignored by your configuration.
+     * @param filePath The path to the file you want to check.
+     * @returns The promise that will be fulfilled with whether the file is ignored or not. If the file is ignored, then
+     *          it will return true.
+     */
+    isPathIgnored(filePath: string): Promise<boolean>;
+    /**
+     * This method lints the files that match the glob patterns and then returns the results.
+     * @param patterns The lint target files. This can contain any of file paths, directory paths, and glob patterns.
+     * @returns The promise that will be fulfilled with an array of LintResult objects.
+     */
+    lintFiles(patterns: string | string[]): Promise<ESLint.LintResult[]>;
+    /**
+     * This method lints the given source code text and then returns the results.
+     *
+     * By default, this method uses the configuration that applies to files in the current working directory (the cwd
+     * constructor option). If you want to use a different configuration, pass options.filePath, and ESLint will load the
+     * same configuration that eslint.lintFiles() would use for a file at options.filePath.
+     *
+     * If the options.filePath value is configured to be ignored, this method returns an empty array. If the
+     * options.warnIgnored option is set along with the options.filePath option, this method returns a LintResult object.
+     * In that case, the result may contain a warning that indicates the file was ignored.
+     * @param code The source code text to check.
+     * @param options The options.
+     * @returns The promise that will be fulfilled with an array of LintResult objects. This is an array (despite there
+     *          being only one lint result) in order to keep the interfaces between this and the eslint.lintFiles()
+     *          method similar.
+     */
+    lintText(code: string, options?: ESLint.LintTextOptions): Promise<ESLint.LintResult[]>;
+    /**
+     * This method loads a formatter. Formatters convert lint results to a human- or machine-readable string.
+     * @param name TThe path to the file you want to check.
+     * The following values are allowed:
+     * - undefined. In this case, loads the "stylish" built-in formatter.
+     * - A name of built-in formatters.
+     * - A name of third-party formatters. For examples:
+     * -- `foo` will load eslint-formatter-foo.
+     * -- `@foo` will load `@foo/eslint-formatter`.
+     * -- `@foo/bar` will load `@foo/eslint-formatter-bar`.
+     * - A path to the file that defines a formatter. The path must contain one or more path separators (/) in order to distinguish if it's a path or not. For example, start with ./.
+     * @returns The promise that will be fulfilled with a Formatter object.
+     */
+    loadFormatter(name?: string): Promise<ESLint.Formatter>;
+    /**
+     * This method copies the given results and removes warnings. The returned value contains only errors.
+     * @param results The LintResult objects to filter.
+     * @returns The filtered LintResult objects.
+     */
+    static getErrorResults(results: ESLint.LintResult): ESLint.LintResult;
+    /**
+     * This method writes code modified by ESLint's autofix feature into its respective file. If any of the modified
+     * files don't exist, this method does nothing.
+     * @param results The LintResult objects to write.
+     * @returns The promise that will be fulfilled after all files are written.
+     */
+    static outputFixes(results: ESLint.LintResult): Promise<void>;
+    /**
+     * The version text.
+     */
+    static readonly version: string;
+}
+declare namespace ESLint {
+    interface ESLintOptions {
+        /**
+         * If false is present, ESLint suppresses directive comments in source code.
+         * If this option is false, it overrides the noInlineConfig setting in your configurations.
+         */
+        allowInlineConfig?: boolean;
+        /**
+         * Configuration object, extended by all configurations used with this instance.
+         * You can use this option to define the default settings that will be used if your configuration files don't
+         * configure it.
+         */
+        baseConfig?: Linter.Config | null;
+        /**
+         * If true is present, the eslint.lintFiles() method caches lint results and uses it if each target file is not
+         * changed. Please mind that ESLint doesn't clear the cache when you upgrade ESLint plugins. In that case, you have
+         * to remove the cache file manually. The eslint.lintText() method doesn't use caches even if you pass the
+         * options.filePath to the method.
+         */
+        cache?: boolean;
+        /**
+         * The eslint.lintFiles() method writes caches into this file.
+         */
+        cacheLocation?: string;
+        /**
+         * The working directory. This must be an absolute path.
+         */
+        cwd?: string;
+        /**
+         * Unless set to false, the eslint.lintFiles() method will throw an error when no target files are found.
+         */
+        errorOnUnmatchedPattern?: boolean;
+        /**
+         * If you pass directory paths to the eslint.lintFiles() method, ESLint checks the files in those directories that
+         * have the given extensions. For example, when passing the src/ directory and extensions is [".js", ".ts"], ESLint
+         * will lint *.js and *.ts files in src/. If extensions is null, ESLint checks *.js files and files that match
+         * overrides[].files patterns in your configuration.
+         * Note: This option only applies when you pass directory paths to the eslint.lintFiles() method.
+         * If you pass glob patterns, ESLint will lint all files matching the glob pattern regardless of extension.
+         */
+        extensions?: string[] | null;
+        /**
+         * If true is present, the eslint.lintFiles() and eslint.lintText() methods work in autofix mode.
+         * If a predicate function is present, the methods pass each lint message to the function, then use only the
+         * lint messages for which the function returned true.
+         */
+        fix?: boolean | ((message: ESLint.LintMessage) => boolean);
+        /**
+         * The types of the rules that the eslint.lintFiles() and eslint.lintText() methods use for autofix.
+         */
+        fixTypes?: ('directive' | 'problem' | 'suggestion' | 'layout')[] | null;
+        /**
+         * If false is present, the eslint.lintFiles() method doesn't interpret glob patterns.
+         */
+        globInputPaths?: boolean;
+        /**
+         * If false is present, the eslint.lintFiles() method doesn't respect `.eslintignore` files or ignorePatterns in
+         * your configuration.
+         */
+        ignore?: boolean;
+        /**
+         * The path to a file ESLint uses instead of `$CWD/.eslintignore`.
+         * If a path is present and the file doesn't exist, this constructor will throw an error.
+         */
+        ignorePath?: string;
+        /**
+         * Configuration object, overrides all configurations used with this instance.
+         * You can use this option to define the settings that will be used even if your configuration files configure it.
+         */
+        overrideConfig?: Linter.ConfigOverride | null;
+        /**
+         * The path to a configuration file, overrides all configurations used with this instance.
+         * The options.overrideConfig option is applied after this option is applied.
+         */
+        overrideConfigFile?: string | null;
+        /**
+         * The plugin implementations that ESLint uses for the plugins setting of your configuration.
+         * This is a map-like object. Those keys are plugin IDs and each value is implementation.
+         */
+        plugins?: Record<string, Linter.Plugin> | null;
+        /**
+         * The severity to report unused eslint-disable directives.
+         * If this option is a severity, it overrides the reportUnusedDisableDirectives setting in your configurations.
+         */
+        reportUnusedDisableDirectives?: Linter.SeverityString | null;
+        /**
+         * The path to a directory where plugins should be resolved from.
+         * If null is present, ESLint loads plugins from the location of the configuration file that contains the plugin
+         * setting.
+         * If a path is present, ESLint loads all plugins from there.
+         */
+        resolvePluginsRelativeTo?: string | null;
+        /**
+         * An array of paths to directories to load custom rules from.
+         */
+        rulePaths?: string[];
+        /**
+         * If false is present, ESLint doesn't load configuration files (.eslintrc.* files).
+         * Only the configuration of the constructor options is valid.
+         */
+        useEslintrc?: boolean;
+    }
+    interface DeprecatedRuleInfo {
+        /**
+         *  The rule ID.
+         */
+        ruleId: string;
+        /**
+         *  The rule IDs that replace this deprecated rule.
+         */
+        replacedBy: string[];
+    }
+    /**
+     * The LintResult value is the information of the linting result of each file.
+     */
+    interface LintResult {
+        /**
+         * The number of errors. This includes fixable errors.
+         */
+        errorCount: number;
+        /**
+         * The number of fatal errors.
+         * @since 7.32.0
+         */
+        fatalErrorCount?: number;
+        /**
+         * The absolute path to the file of this result. This is the string "<text>" if the file path is unknown (when you
+         * didn't pass the options.filePath option to the eslint.lintText() method).
+         */
+        filePath: string;
+        /**
+         * The number of errors that can be fixed automatically by the fix constructor option.
+         */
+        fixableErrorCount: number;
+        /**
+         * The number of warnings that can be fixed automatically by the fix constructor option.
+         */
+        fixableWarningCount: number;
+        /**
+         * The array of LintMessage objects.
+         */
+        messages: ESLint.LintMessage[];
+        /**
+         * The source code of the file that was linted, with as many fixes applied as possible.
+         */
+        output?: string;
+        /**
+         * The original source code text. This property is undefined if any messages didn't exist or the output
+         * property exists.
+         */
+        source?: string;
+        /**
+         * The array of SuppressedLintMessage objects.
+         *
+         * @since 8.8.0
+         */
+        suppressedMessages?: SuppressedLintMessage[];
+        /**
+         * The information about the deprecated rules that were used to check this file.
+         */
+        usedDeprecatedRules: DeprecatedRuleInfo[];
+        /**
+         * The number of warnings. This includes fixable warnings.
+         */
+        warningCount: number;
+    }
+    interface LintTextOptions {
+        /**
+         * The path to the file of the source code text. If omitted, the result.filePath becomes the string "<text>".
+         */
+        filePath?: string;
+        /**
+         * If true is present and the options.filePath is a file ESLint should ignore, this method returns a lint result
+         * contains a warning message.
+         */
+        warnIgnored?: boolean;
+    }
+    /**
+     * The LintMessage value is the information of each linting error.
+     */
+    interface LintMessage {
+        /**
+         * The 1-based column number of the begin point of this message.
+         */
+        column: number | undefined;
+        /**
+         * The 1-based column number of the end point of this message. This property is undefined if this message
+         * is not a range.
+         */
+        endColumn: number | undefined;
+        /**
+         * The 1-based line number of the end point of this message. This property is undefined if this
+         * message is not a range.
+         */
+        endLine: number | undefined;
+        /**
+         * `true` if this is a fatal error unrelated to a rule, like a parsing error.
+         * @since 7.24.0
+         */
+        fatal?: boolean | undefined;
+        /**
+         * The EditInfo object of autofix. This property is undefined if this message is not fixable.
+         */
+        fix: EditInfo | undefined;
+        /**
+         * The 1-based line number of the begin point of this message.
+         */
+        line: number | undefined;
+        /**
+         * The error message
+         */
+        message: string;
+        /**
+         * The rule name that generates this lint message. If this message is generated by the ESLint core rather than
+         * rules, this is null.
+         */
+        ruleId: string | null;
+        /**
+         * The severity of this message. 1 means warning and 2 means error.
+         */
+        severity: 1 | 2;
+        /**
+         * The list of suggestions. Each suggestion is the pair of a description and an EditInfo object to fix code. API
+         * users such as editor integrations can choose one of them to fix the problem of this message. This property is
+         * undefined if this message doesn't have any suggestions.
+         */
+        suggestions: {
+            desc: string;
+            fix: EditInfo;
+        }[] | undefined;
+    }
+    /**
+     * The SuppressedLintMessage value is the information of each suppressed linting error.
+     */
+    interface SuppressedLintMessage extends ESLint.LintMessage {
+        /**
+         * The list of suppressions.
+         */
+        suppressions?: {
+            /**
+             * Right now, this is always `directive`
+             */
+            kind: string;
+            /**
+             * The free text description added after the `--` in the comment
+             */
+            justification: string;
+        }[];
+    }
+    /**
+     * The EditInfo value is information to edit text.
+     *
+     * This edit information means replacing the range of the range property by the text property value. It's like
+     * sourceCodeText.slice(0, edit.range[0]) + edit.text + sourceCodeText.slice(edit.range[1]). Therefore, it's an add
+     * if the range[0] and range[1] property values are the same value, and it's removal if the text property value is
+     * empty string.
+     */
+    interface EditInfo {
+        /**
+         * The pair of 0-based indices in source code text to remove.
+         */
+        range: [
+            number,
+            number
+        ];
+        /**
+         * The text to add.
+         */
+        text: string;
+    }
+    /**
+     * The Formatter value is the object to convert the LintResult objects to text.
+     */
+    interface Formatter {
+        /**
+         * The method to convert the LintResult objects to text.
+         * Promise return supported since 8.4.0
+         */
+        format(results: LintResult[]): string | Promise<string>;
+    }
+}
+declare const _ESLint: typeof ESLintBase;
+/**
+ * The ESLint class is the primary class to use in Node.js applications.
+ * This class depends on the Node.js fs module and the file system, so you cannot use it in browsers.
+ *
+ * If you want to lint code on browsers, use the Linter class instead.
+ *
+ * @since 7.0.0
+ */
+declare class ESLint extends _ESLint {
+}
+export { ESLint };
+//# sourceMappingURL=ESLint.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ts-eslint/Linter.d.ts

@@ -0,0 +1,326 @@
+import { TSESTree, ParserServices } from '../ts-estree';
+import { ParserOptions as TSParserOptions } from './ParserOptions';
+import { RuleCreateFunction, RuleFix, RuleModule, SharedConfigurationSettings } from './Rule';
+import { Scope } from './Scope';
+import { SourceCode } from './SourceCode';
+declare class LinterBase {
+    /**
+     * Initialize the Linter.
+     * @param config the config object
+     */
+    constructor(config?: Linter.LinterOptions);
+    /**
+     * Define a new parser module
+     * @param parserId Name of the parser
+     * @param parserModule The parser object
+     */
+    defineParser(parserId: string, parserModule: Linter.ParserModule): void;
+    /**
+     * Defines a new linting rule.
+     * @param ruleId A unique rule identifier
+     * @param ruleModule Function from context to object mapping AST node types to event handlers
+     */
+    defineRule<TMessageIds extends string, TOptions extends readonly unknown[]>(ruleId: string, ruleModule: RuleModule<TMessageIds, TOptions> | RuleCreateFunction): void;
+    /**
+     * Defines many new linting rules.
+     * @param rulesToDefine map from unique rule identifier to rule
+     */
+    defineRules<TMessageIds extends string, TOptions extends readonly unknown[]>(rulesToDefine: Record<string, RuleModule<TMessageIds, TOptions> | RuleCreateFunction>): void;
+    /**
+     * Gets an object with all loaded rules.
+     * @returns All loaded rules
+     */
+    getRules(): Map<string, RuleModule<string, unknown[]>>;
+    /**
+     * Gets the `SourceCode` object representing the parsed source.
+     * @returns The `SourceCode` object.
+     */
+    getSourceCode(): SourceCode;
+    /**
+     * Verifies the text against the rules specified by the second argument.
+     * @param textOrSourceCode The text to parse or a SourceCode object.
+     * @param config An ESLintConfig instance to configure everything.
+     * @param filenameOrOptions The optional filename of the file being checked.
+     *        If this is not set, the filename will default to '<input>' in the rule context.
+     *        If this is an object, then it has "filename", "allowInlineConfig", and some properties.
+     * @returns The results as an array of messages or an empty array if no messages.
+     */
+    verify(textOrSourceCode: SourceCode | string, config: Linter.Config, filenameOrOptions?: string | Linter.VerifyOptions): Linter.LintMessage[];
+    /**
+     * Performs multiple autofix passes over the text until as many fixes as possible have been applied.
+     * @param code The source text to apply fixes to.
+     * @param config The ESLint config object to use.
+     * @param options The ESLint options object to use.
+     * @returns The result of the fix operation as returned from the SourceCodeFixer.
+     */
+    verifyAndFix(code: string, config: Linter.Config, options: Linter.FixOptions): Linter.FixReport;
+    /**
+     * The version from package.json.
+     */
+    readonly version: string;
+    /**
+     * The version from package.json.
+     */
+    static readonly version: string;
+}
+declare namespace Linter {
+    export interface LinterOptions {
+        /**
+         * path to a directory that should be considered as the current working directory.
+         */
+        cwd?: string;
+    }
+    export type Severity = 0 | 1 | 2;
+    export type SeverityString = 'off' | 'warn' | 'error';
+    export type RuleLevel = Severity | SeverityString;
+    export type RuleLevelAndOptions = [
+        RuleLevel,
+        ...unknown[]
+    ];
+    export type RuleEntry = RuleLevel | RuleLevelAndOptions;
+    export type RulesRecord = Partial<Record<string, RuleEntry>>;
+    export type GlobalVariableOption = 'readonly' | 'writable' | 'off' | boolean;
+    interface BaseConfig {
+        $schema?: string;
+        /**
+         * The environment settings.
+         */
+        env?: {
+            [name: string]: boolean;
+        };
+        /**
+         * The path to other config files or the package name of shareable configs.
+         */
+        extends?: string | string[];
+        /**
+         * The global variable settings.
+         */
+        globals?: {
+            [name: string]: GlobalVariableOption;
+        };
+        /**
+         * The flag that disables directive comments.
+         */
+        noInlineConfig?: boolean;
+        /**
+         * The override settings per kind of files.
+         */
+        overrides?: ConfigOverride[];
+        /**
+         * The path to a parser or the package name of a parser.
+         */
+        parser?: string;
+        /**
+         * The parser options.
+         */
+        parserOptions?: ParserOptions;
+        /**
+         * The plugin specifiers.
+         */
+        plugins?: string[];
+        /**
+         * The processor specifier.
+         */
+        processor?: string;
+        /**
+         * The flag to report unused `eslint-disable` comments.
+         */
+        reportUnusedDisableDirectives?: boolean;
+        /**
+         * The rule settings.
+         */
+        rules?: RulesRecord;
+        /**
+         * The shared settings.
+         */
+        settings?: SharedConfigurationSettings;
+    }
+    export interface ConfigOverride extends BaseConfig {
+        excludedFiles?: string | string[];
+        files: string | string[];
+    }
+    export interface Config extends BaseConfig {
+        /**
+         * The glob patterns that ignore to lint.
+         */
+        ignorePatterns?: string | string[];
+        /**
+         * The root flag.
+         */
+        root?: boolean;
+    }
+    export type ParserOptions = TSParserOptions;
+    export interface VerifyOptions {
+        /**
+         * Allow/disallow inline comments' ability to change config once it is set. Defaults to true if not supplied.
+         * Useful if you want to validate JS without comments overriding rules.
+         */
+        allowInlineConfig?: boolean;
+        /**
+         * if `true` then the linter doesn't make `fix` properties into the lint result.
+         */
+        disableFixes?: boolean;
+        /**
+         * the filename of the source code.
+         */
+        filename?: string;
+        /**
+         * the predicate function that selects adopt code blocks.
+         */
+        filterCodeBlock?: (filename: string, text: string) => boolean;
+        /**
+         * postprocessor for report messages.
+         * If provided, this should accept an array of the message lists
+         * for each code block returned from the preprocessor, apply a mapping to
+         * the messages as appropriate, and return a one-dimensional array of
+         * messages.
+         */
+        postprocess?: Processor['postprocess'];
+        /**
+         * preprocessor for source text.
+         * If provided, this should accept a string of source text, and return an array of code blocks to lint.
+         */
+        preprocess?: Processor['preprocess'];
+        /**
+         * Adds reported errors for unused `eslint-disable` directives.
+         */
+        reportUnusedDisableDirectives?: boolean | SeverityString;
+    }
+    export interface FixOptions extends VerifyOptions {
+        /**
+         * Determines whether fixes should be applied.
+         */
+        fix?: boolean;
+    }
+    export interface LintSuggestion {
+        desc: string;
+        fix: RuleFix;
+        messageId?: string;
+    }
+    export interface LintMessage {
+        /**
+         * The 1-based column number.
+         */
+        column: number;
+        /**
+         * The 1-based column number of the end location.
+         */
+        endColumn?: number;
+        /**
+         * The 1-based line number of the end location.
+         */
+        endLine?: number;
+        /**
+         * If `true` then this is a fatal error.
+         */
+        fatal?: true;
+        /**
+         * Information for autofix.
+         */
+        fix?: RuleFix;
+        /**
+         * The 1-based line number.
+         */
+        line: number;
+        /**
+         * The error message.
+         */
+        message: string;
+        messageId?: string;
+        nodeType: string;
+        /**
+         * The ID of the rule which makes this message.
+         */
+        ruleId: string | null;
+        /**
+         * The severity of this message.
+         */
+        severity: Severity;
+        source: string | null;
+        /**
+         * Information for suggestions
+         */
+        suggestions?: LintSuggestion[];
+    }
+    export interface FixReport {
+        /**
+         * True, if the code was fixed
+         */
+        fixed: boolean;
+        /**
+         * Fixed code text (might be the same as input if no fixes were applied).
+         */
+        output: string;
+        /**
+         * Collection of all messages for the given code
+         */
+        messages: LintMessage[];
+    }
+    export type ParserModule = {
+        parse(text: string, options?: ParserOptions): TSESTree.Program;
+    } | {
+        parseForESLint(text: string, options?: ParserOptions): ESLintParseResult;
+    };
+    export interface ESLintParseResult {
+        ast: TSESTree.Program;
+        services?: ParserServices;
+        scopeManager?: Scope.ScopeManager;
+        visitorKeys?: SourceCode.VisitorKeys;
+    }
+    export interface Processor {
+        /**
+         * The function to extract code blocks.
+         */
+        preprocess?: (text: string, filename: string) => Array<string | {
+            text: string;
+            filename: string;
+        }>;
+        /**
+         * The function to merge messages.
+         */
+        postprocess?: (messagesList: Linter.LintMessage[][], filename: string) => Linter.LintMessage[];
+        /**
+         * If `true` then it means the processor supports autofix.
+         */
+        supportsAutofix?: boolean;
+    }
+    export interface Environment {
+        /**
+         * The definition of global variables.
+         */
+        globals?: Record<string, Linter.Config>;
+        /**
+         * The parser options that will be enabled under this environment.
+         */
+        parserOptions?: ParserOptions;
+    }
+    export interface Plugin {
+        /**
+         * The definition of plugin configs.
+         */
+        configs?: Record<string, Linter.Config>;
+        /**
+         * The definition of plugin environments.
+         */
+        environments?: Record<string, Environment>;
+        /**
+         * The definition of plugin processors.
+         */
+        processors?: Record<string, Processor>;
+        /**
+         * The definition of plugin rules.
+         */
+        rules?: Record<string, RuleCreateFunction | RuleModule<string, unknown[]>>;
+    }
+    export {};
+}
+declare const Linter_base: typeof LinterBase;
+/**
+ * The Linter object does the actual evaluation of the JavaScript code. It doesn't do any filesystem operations, it
+ * simply parses and reports on the code. In particular, the Linter object does not process configuration objects
+ * or files.
+ */
+declare class Linter extends Linter_base {
+}
+export { Linter };
+//# sourceMappingURL=Linter.d.ts.map