eslint-plugin-ferramentas/dist/Rules/Base.d.ts

A bundle of useful ESLint rules

import type { JSONSchema4 } from 'json-schema';
import type { AST, Rule, SourceCode } from 'eslint';
import type { ImportDeclaration, Node, SourceLocation } from 'estree';
import { type ReadonlyRecord } from '../utils';
export type BaseRuleOptionInputTemplate<T> = readonly [Readonly<T>];
export declare const createBaseRuleOptionInputMapper: <I, O>(mapper: (input: I) => O) => ([input]: BaseRuleOptionInputTemplate<I>) => O;
declare abstract class ExtendedNode<N extends Node = Node> {
    protected readonly node: N;
    protected readonly context: Rule.RuleContext;
    private readonly getFirstComment;
    protected abstract readonly NodeConstructor: new (node: N, context: Rule.RuleContext) => ExtendedNode<N>;
    private static getProperty;
    private static sortPositions;
    constructor(node: N, context: Rule.RuleContext);
    protected abstract get siblings(): readonly Node[];
    protected get sourceCode(): SourceCode;
    private getProperty;
    protected abstract isNode(node: Node): node is N;
    protected getPreviousSiblingWithSameTypeOrThrow(): ExtendedNode<N>;
    getLocation(withComments: boolean): SourceLocation;
    getRange(withComments: boolean): AST.Range;
    getRangeBetween<OtherNode extends Node>(destination: ExtendedNode<OtherNode>, withComments: boolean): AST.Range;
    toString(withComments?: boolean): string;
}
declare class ExtendedImportDeclaration extends ExtendedNode<ImportDeclaration> {
    protected readonly NodeConstructor: typeof ExtendedImportDeclaration;
    private readonly getRawPath;
    private readonly getPathFromWorkingDirectory;
    protected get siblings(): readonly Node[];
    get rawPath(): string;
    get pathFromWorkingDirectory(): string;
    protected isNode(node: Node): node is ImportDeclaration;
    getPreviousSiblingWithSameTypeOrThrow(): ExtendedImportDeclaration;
}
export type { ExtendedImportDeclaration };
declare class RuleContextWrapper<OptionsInput, Options extends Readonly<{
    debug: boolean;
}>, ErrorMessages extends string> {
    private readonly context;
    readonly ruleName: string;
    private readonly mapOptions;
    private readonly getOptions;
    private readonly createDebugger;
    constructor(context: Rule.RuleContext, ruleName: string, mapOptions: (input: OptionsInput) => Options);
    getRelativeFilename(): string;
    getImportDeclaration(node: ImportDeclaration): ExtendedImportDeclaration;
    getOption<K extends keyof Options>(name: K): Options[K];
    debug(...values: readonly Readonly<{
        toString: () => string;
    }>[]): void;
    report(descriptor: Rule.ReportDescriptor & Readonly<{
        messageId: ErrorMessages;
        loc: SourceLocation;
    }>): void;
}
type Metadata<ErrorMessages extends string> = Rule.RuleMetaData & Readonly<{
    schema: JSONSchema4;
    docs: Readonly<{
        description: string;
    }>;
    messages: ReadonlyRecord<ErrorMessages, string>;
}>;
export declare const createRule: <OptionsInput, Options extends Readonly<{
    debug: boolean;
}>, ErrorMessages extends string>({ name, ...meta }: Rule.RuleMetaData & Readonly<{
    schema: JSONSchema4;
    docs: Readonly<{
        description: string;
    }>;
    messages: Readonly<Record<ErrorMessages, string>>;
}> & Readonly<{
    name: string;
}>, mapOptions: (input: OptionsInput) => Options, create: (context: RuleContextWrapper<OptionsInput, Options, ErrorMessages>) => Rule.RuleListener) => Readonly<Record<string, Rule.RuleModule & Readonly<{
    meta: Metadata<ErrorMessages>;
}>>>;