eslint-plugin-vue-scoped-css

import selectorParser from "postcss-selector-parser"; import { AST as AST$1 } from "vue-eslint-parser"; import { Linter } from "eslint"; //#region node_modules/@types/estree/index.d.ts // This definition file follows a somewhat unusual format. ESTree allows // runtime type checks based on the `type` parameter. In order to explain this // to typescript we want to use discriminated union types: // https://github.com/Microsoft/TypeScript/pull/9163 // // For ESTree this is a bit tricky because the high level interfaces like // Node or Function are pulling double duty. We want to pass common fields down // to the interfaces that extend them (like Identifier or // ArrowFunctionExpression), but you can't extend a type union or enforce // common fields on them. So we've split the high level interfaces into two // types, a base type which passes down inherited fields, and a type union of // all types which extend the base type. Only the type union is exported, and // the union is how other types refer to the collection of inheriting types. // // This makes the definitions file here somewhat more difficult to maintain, // but it has the notable advantage of making ESTree much easier to use as // an end user. interface BaseNodeWithoutComments { // Every leaf interface that extends BaseNode must specify a type property. // The type property should be a string literal. For example, Identifier // has: `type: "Identifier"` type: string; loc?: SourceLocation$1 | null | undefined; range?: [number, number] | undefined; } interface BaseNode extends BaseNodeWithoutComments { leadingComments?: Comment[] | undefined; trailingComments?: Comment[] | undefined; } interface NodeMap { AssignmentProperty: AssignmentProperty; CatchClause: CatchClause; Class: Class; ClassBody: ClassBody; Expression: Expression; Function: Function; Identifier: Identifier; Literal: Literal; MethodDefinition: MethodDefinition; ModuleDeclaration: ModuleDeclaration; ModuleSpecifier: ModuleSpecifier; Pattern: Pattern; PrivateIdentifier: PrivateIdentifier; Program: Program; Property: Property; PropertyDefinition: PropertyDefinition; SpreadElement: SpreadElement; Statement: Statement; Super: Super; SwitchCase: SwitchCase; TemplateElement: TemplateElement; VariableDeclarator: VariableDeclarator; } type Node = NodeMap[keyof NodeMap]; interface Comment extends BaseNodeWithoutComments { type: "Line" | "Block"; value: string; } interface SourceLocation$1 { source?: string | null | undefined; start: Position; end: Position; } interface Position { /** >= 1 */ line: number; /** >= 0 */ column: number; } interface Program extends BaseNode { type: "Program"; sourceType: "script" | "module"; body: Array<Directive | Statement | ModuleDeclaration>; comments?: Comment[] | undefined; } interface Directive extends BaseNode { type: "ExpressionStatement"; expression: Literal; directive: string; } interface BaseFunction extends BaseNode { params: Pattern[]; generator?: boolean | undefined; async?: boolean | undefined; // The body is either BlockStatement or Expression because arrow functions // can have a body that's either. FunctionDeclarations and // FunctionExpressions have only BlockStatement bodies. body: BlockStatement | Expression; } type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression; type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration; interface BaseStatement extends BaseNode {} interface EmptyStatement extends BaseStatement { type: "EmptyStatement"; } interface BlockStatement extends BaseStatement { type: "BlockStatement"; body: Statement[]; innerComments?: Comment[] | undefined; } interface StaticBlock extends Omit<BlockStatement, "type"> { type: "StaticBlock"; } interface ExpressionStatement extends BaseStatement { type: "ExpressionStatement"; expression: Expression; } interface IfStatement extends BaseStatement { type: "IfStatement"; test: Expression; consequent: Statement; alternate?: Statement | null | undefined; } interface LabeledStatement extends BaseStatement { type: "LabeledStatement"; label: Identifier; body: Statement; } interface BreakStatement extends BaseStatement { type: "BreakStatement"; label?: Identifier | null | undefined; } interface ContinueStatement extends BaseStatement { type: "ContinueStatement"; label?: Identifier | null | undefined; } interface WithStatement extends BaseStatement { type: "WithStatement"; object: Expression; body: Statement; } interface SwitchStatement extends BaseStatement { type: "SwitchStatement"; discriminant: Expression; cases: SwitchCase[]; } interface ReturnStatement extends BaseStatement { type: "ReturnStatement"; argument?: Expression | null | undefined; } interface ThrowStatement extends BaseStatement { type: "ThrowStatement"; argument: Expression; } interface TryStatement extends BaseStatement { type: "TryStatement"; block: BlockStatement; handler?: CatchClause | null | undefined; finalizer?: BlockStatement | null | undefined; } interface WhileStatement extends BaseStatement { type: "WhileStatement"; test: Expression; body: Statement; } interface DoWhileStatement extends BaseStatement { type: "DoWhileStatement"; body: Statement; test: Expression; } interface ForStatement extends BaseStatement { type: "ForStatement"; init?: VariableDeclaration | Expression | null | undefined; test?: Expression | null | undefined; update?: Expression | null | undefined; body: Statement; } interface BaseForXStatement extends BaseStatement { left: VariableDeclaration | Pattern; right: Expression; body: Statement; } interface ForInStatement extends BaseForXStatement { type: "ForInStatement"; } interface DebuggerStatement extends BaseStatement { type: "DebuggerStatement"; } type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration; interface BaseDeclaration extends BaseStatement {} interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration { type: "FunctionDeclaration"; /** It is null when a function declaration is a part of the `export default function` statement */ id: Identifier | null; body: BlockStatement; } interface FunctionDeclaration extends MaybeNamedFunctionDeclaration { id: Identifier; } interface VariableDeclaration extends BaseDeclaration { type: "VariableDeclaration"; declarations: VariableDeclarator[]; kind: "var" | "let" | "const" | "using" | "await using"; } interface VariableDeclarator extends BaseNode { type: "VariableDeclarator"; id: Pattern; init?: Expression | null | undefined; } interface ExpressionMap { ArrayExpression: ArrayExpression; ArrowFunctionExpression: ArrowFunctionExpression; AssignmentExpression: AssignmentExpression; AwaitExpression: AwaitExpression; BinaryExpression: BinaryExpression; CallExpression: CallExpression; ChainExpression: ChainExpression; ClassExpression: ClassExpression; ConditionalExpression: ConditionalExpression; FunctionExpression: FunctionExpression; Identifier: Identifier; ImportExpression: ImportExpression; Literal: Literal; LogicalExpression: LogicalExpression; MemberExpression: MemberExpression; MetaProperty: MetaProperty; NewExpression: NewExpression; ObjectExpression: ObjectExpression; SequenceExpression: SequenceExpression; TaggedTemplateExpression: TaggedTemplateExpression; TemplateLiteral: TemplateLiteral; ThisExpression: ThisExpression; UnaryExpression: UnaryExpression; UpdateExpression: UpdateExpression; YieldExpression: YieldExpression; } type Expression = ExpressionMap[keyof ExpressionMap]; interface BaseExpression extends BaseNode {} type ChainElement = SimpleCallExpression | MemberExpression; interface ChainExpression extends BaseExpression { type: "ChainExpression"; expression: ChainElement; } interface ThisExpression extends BaseExpression { type: "ThisExpression"; } interface ArrayExpression extends BaseExpression { type: "ArrayExpression"; elements: Array<Expression | SpreadElement | null>; } interface ObjectExpression extends BaseExpression { type: "ObjectExpression"; properties: Array<Property | SpreadElement>; } interface PrivateIdentifier extends BaseNode { type: "PrivateIdentifier"; name: string; } interface Property extends BaseNode { type: "Property"; key: Expression | PrivateIdentifier; value: Expression | Pattern; // Could be an AssignmentProperty kind: "init" | "get" | "set"; method: boolean; shorthand: boolean; computed: boolean; } interface PropertyDefinition extends BaseNode { type: "PropertyDefinition"; key: Expression | PrivateIdentifier; value?: Expression | null | undefined; computed: boolean; static: boolean; } interface FunctionExpression extends BaseFunction, BaseExpression { id?: Identifier | null | undefined; type: "FunctionExpression"; body: BlockStatement; } interface SequenceExpression extends BaseExpression { type: "SequenceExpression"; expressions: Expression[]; } interface UnaryExpression extends BaseExpression { type: "UnaryExpression"; operator: UnaryOperator; prefix: true; argument: Expression; } interface BinaryExpression extends BaseExpression { type: "BinaryExpression"; operator: BinaryOperator; left: Expression | PrivateIdentifier; right: Expression; } interface AssignmentExpression extends BaseExpression { type: "AssignmentExpression"; operator: AssignmentOperator; left: Pattern | MemberExpression; right: Expression; } interface UpdateExpression extends BaseExpression { type: "UpdateExpression"; operator: UpdateOperator; argument: Expression; prefix: boolean; } interface LogicalExpression extends BaseExpression { type: "LogicalExpression"; operator: LogicalOperator; left: Expression; right: Expression; } interface ConditionalExpression extends BaseExpression { type: "ConditionalExpression"; test: Expression; alternate: Expression; consequent: Expression; } interface BaseCallExpression extends BaseExpression { callee: Expression | Super; arguments: Array<Expression | SpreadElement>; } type CallExpression = SimpleCallExpression | NewExpression; interface SimpleCallExpression extends BaseCallExpression { type: "CallExpression"; optional: boolean; } interface NewExpression extends BaseCallExpression { type: "NewExpression"; } interface MemberExpression extends BaseExpression, BasePattern { type: "MemberExpression"; object: Expression | Super; property: Expression | PrivateIdentifier; computed: boolean; optional: boolean; } type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression; interface BasePattern extends BaseNode {} interface SwitchCase extends BaseNode { type: "SwitchCase"; test?: Expression | null | undefined; consequent: Statement[]; } interface CatchClause extends BaseNode { type: "CatchClause"; param: Pattern | null; body: BlockStatement; } interface Identifier extends BaseNode, BaseExpression, BasePattern { type: "Identifier"; name: string; } type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral; interface SimpleLiteral extends BaseNode, BaseExpression { type: "Literal"; value: string | boolean | number | null; raw?: string | undefined; } interface RegExpLiteral extends BaseNode, BaseExpression { type: "Literal"; value?: RegExp | null | undefined; regex: { pattern: string; flags: string; }; raw?: string | undefined; } interface BigIntLiteral extends BaseNode, BaseExpression { type: "Literal"; value?: bigint | null | undefined; bigint: string; raw?: string | undefined; } type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete"; type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof"; type LogicalOperator = "||" | "&&" | "??"; type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??="; type UpdateOperator = "++" | "--"; interface ForOfStatement extends BaseForXStatement { type: "ForOfStatement"; await: boolean; } interface Super extends BaseNode { type: "Super"; } interface SpreadElement extends BaseNode { type: "SpreadElement"; argument: Expression; } interface ArrowFunctionExpression extends BaseExpression, BaseFunction { type: "ArrowFunctionExpression"; expression: boolean; body: BlockStatement | Expression; } interface YieldExpression extends BaseExpression { type: "YieldExpression"; argument?: Expression | null | undefined; delegate: boolean; } interface TemplateLiteral extends BaseExpression { type: "TemplateLiteral"; quasis: TemplateElement[]; expressions: Expression[]; } interface TaggedTemplateExpression extends BaseExpression { type: "TaggedTemplateExpression"; tag: Expression; quasi: TemplateLiteral; } interface TemplateElement extends BaseNode { type: "TemplateElement"; tail: boolean; value: { /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */cooked?: string | null | undefined; raw: string; }; } interface AssignmentProperty extends Property { value: Pattern; kind: "init"; method: boolean; // false } interface ObjectPattern extends BasePattern { type: "ObjectPattern"; properties: Array<AssignmentProperty | RestElement>; } interface ArrayPattern extends BasePattern { type: "ArrayPattern"; elements: Array<Pattern | null>; } interface RestElement extends BasePattern { type: "RestElement"; argument: Pattern; } interface AssignmentPattern extends BasePattern { type: "AssignmentPattern"; left: Pattern; right: Expression; } type Class = ClassDeclaration | ClassExpression; interface BaseClass extends BaseNode { superClass?: Expression | null | undefined; body: ClassBody; } interface ClassBody extends BaseNode { type: "ClassBody"; body: Array<MethodDefinition | PropertyDefinition | StaticBlock>; } interface MethodDefinition extends BaseNode { type: "MethodDefinition"; key: Expression | PrivateIdentifier; value: FunctionExpression; kind: "constructor" | "method" | "get" | "set"; computed: boolean; static: boolean; } interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration { type: "ClassDeclaration"; /** It is null when a class declaration is a part of the `export default class` statement */ id: Identifier | null; } interface ClassDeclaration extends MaybeNamedClassDeclaration { id: Identifier; } interface ClassExpression extends BaseClass, BaseExpression { type: "ClassExpression"; id?: Identifier | null | undefined; } interface MetaProperty extends BaseExpression { type: "MetaProperty"; meta: Identifier; property: Identifier; } type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration; interface BaseModuleDeclaration extends BaseNode {} type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier; interface BaseModuleSpecifier extends BaseNode { local: Identifier; } interface ImportDeclaration extends BaseModuleDeclaration { type: "ImportDeclaration"; specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>; attributes: ImportAttribute[]; source: Literal; } interface ImportSpecifier extends BaseModuleSpecifier { type: "ImportSpecifier"; imported: Identifier | Literal; } interface ImportAttribute extends BaseNode { type: "ImportAttribute"; key: Identifier | Literal; value: Literal; } interface ImportExpression extends BaseExpression { type: "ImportExpression"; source: Expression; options?: Expression | null | undefined; } interface ImportDefaultSpecifier extends BaseModuleSpecifier { type: "ImportDefaultSpecifier"; } interface ImportNamespaceSpecifier extends BaseModuleSpecifier { type: "ImportNamespaceSpecifier"; } interface ExportNamedDeclaration extends BaseModuleDeclaration { type: "ExportNamedDeclaration"; declaration?: Declaration | null | undefined; specifiers: ExportSpecifier[]; attributes: ImportAttribute[]; source?: Literal | null | undefined; } interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> { type: "ExportSpecifier"; local: Identifier | Literal; exported: Identifier | Literal; } interface ExportDefaultDeclaration extends BaseModuleDeclaration { type: "ExportDefaultDeclaration"; declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression; } interface ExportAllDeclaration extends BaseModuleDeclaration { type: "ExportAllDeclaration"; exported: Identifier | Literal | null; attributes: ImportAttribute[]; source: Literal; } interface AwaitExpression extends BaseExpression { type: "AwaitExpression"; argument: Expression; } //#endregion //#region typings/eslint-scope/index.d.ts interface ScopeManager { scopes: Scope[]; globalScope: Scope; acquire(node: Node, inner: boolean): Scope | null; acquireAll(node: Node): Scope[]; } interface Scope { block: Node; childScopes: Scope[]; directCallToEcalScope: boolean; dynamic: boolean; functionExpressionScope: boolean; isStrict: boolean; references: Reference[]; set: Map<string, Variable>; taints: Map<string, boolean>; thisFound: boolean; through: Reference[]; type: string; upper: Scope | null; variables: Variable[]; variableScope: Scope; } interface Variable { defs: VariableDefinition[]; identifiers: Identifier[]; name: string; references: Reference[]; scope: Scope; stack: boolean; } interface VariableDefinition { type: string; name: Identifier; node: Node; parent?: Node; } interface Reference { from: Scope; identifier: Identifier; partial: boolean; resolved: Variable | null; tainted: boolean; writeExpr: Expression; isRead(): boolean; isReadOnly(): boolean; isReadWrite(): boolean; isStatic(): boolean; isWrite(): boolean; isWriteOnly(): boolean; } //#endregion //#region lib/types.d.ts interface RuleListener { [key: string]: ((node: never) => void) | undefined; } type Rule = { create(context: RuleContext): RuleListener; meta: { docs: { description: string; categories: ("vue2-recommended" | "vue3-recommended")[]; ruleId?: string; ruleName?: string; default?: Linter.RuleSeverity; replacedBy?: string[]; url: string; suggestion?: true; }; deprecated?: boolean; fixable?: "code" | "whitespace" | null; hasSuggestions?: boolean; schema: unknown[]; messages: { [key: string]: string; }; type: "suggestion" | "problem"; }; }; type LineAndColumnData = AST$1.Location; type SourceLocation = AST$1.LocationRange; type Range = [number, number]; interface ParserServices { /** * Get the token store of the template body. * @returns The token store of template body. */ getTemplateBodyTokenStore?: () => TokenStore; /** * Get the root document fragment. * @returns The root document fragment. */ getDocumentFragment?: () => AST$1.VDocumentFragment | null; } interface RuleContext { id: string; sourceCode: SourceCode; report: (descriptor: ReportDescriptor) => void; options: any[]; filename: string; physicalFilename: string; cwd: string; parserServices: ParserServices; } interface Fix { range: Range; text: string; } interface RuleFixer { insertTextAfter(nodeOrToken: any, text: string): Fix; insertTextAfterRange(range: Range, text: string): Fix; insertTextBefore(nodeOrToken: any, text: string): Fix; insertTextBeforeRange(range: Range, text: string): Fix; remove(nodeOrToken: any): Fix; removeRange(range: Range): Fix; replaceText(nodeOrToken: any, text: string): Fix; replaceTextRange(range: Range, text: string): Fix; } type ReportSuggestion = ({ messageId: string; } | { desc: string; }) & { data?: { [key: string]: string; }; fix?(fixer: RuleFixer): null | Fix | Fix[] | IterableIterator<Fix>; }; type ReportDescriptorNodeLocation = { node: AST$1.HasLocation; }; type ReportDescriptorSourceLocation = { loc: SourceLocation | { line: number; column: number; }; }; type ReportDescriptorLocation = ReportDescriptorNodeLocation | ReportDescriptorSourceLocation; type ReportDescriptor = ReportDescriptorLocation & Rule.ReportDescriptorOptions & Rule.ReportDescriptorMessage & { suggest?: ReportSuggestion[]; }; type FilterPredicate = (tokenOrComment: AST$1.Token) => boolean; type CursorWithSkipOptions = number | FilterPredicate | { includeComments?: boolean; filter?: FilterPredicate; skip?: number; }; interface SourceCode { text: string; ast: AST$1.ESLintProgram; lines: string[]; hasBOM: boolean; visitorKeys: any; scopeManager: ScopeManager; parserServices: ParserServices; getAllComments: () => AST$1.Token[]; getText(node?: AST$1.Node, beforeCount?: number, afterCount?: number): string; getLines(): string[]; getNodeByRangeIndex(index: number): AST$1.ESLintNode | null; getLocFromIndex(index: number): LineAndColumnData; getIndexFromLoc(location: LineAndColumnData): number; getFirstToken(node: AST$1.Node, options?: CursorWithSkipOptions): AST$1.Token | null; } interface TokenStore { getFirstToken(node: AST$1.Node, options?: CursorWithSkipOptions): AST$1.Token | null; getLastToken(node: AST$1.Node, options?: CursorWithSkipOptions): AST$1.Token | null; getTokens(node: AST$1.Node, beforeCount?: number, afterCount?: number): AST$1.Token[]; getTokenBefore(node: AST$1.Node): AST$1.Token; getTokenAfter(node: AST$1.Node): AST$1.Token; } //#endregion //#region lib/index.d.ts type Configs = { base: Linter.Config[]; recommended: Linter.Config[]; "vue2-recommended": Linter.Config[]; all: Linter.Config[]; "flat/base": Linter.Config[]; "flat/recommended": Linter.Config[]; "flat/vue2-recommended": Linter.Config[]; "flat/all": Linter.Config[]; }; declare const _default: { configs: Configs; rules: { [key: string]: Rule; }; }; //#endregion export { _default as default };