codelyzer

codelyzer

Version 6.0.2
Published 4 years ago
571 kB
14 dependencies
MIT license

Install

npm i codelyzer

yarn add codelyzer

pnpm add codelyzer

Overview

Linting for Angular applications, following angular.io/styleguide.

Index

Variables

Config
LogLevel
rulesDirectory

Classes

AngularWhitespaceRule
BasicCssAstVisitor
BasicTemplateAstVisitor
ComponentClassSuffixRule
ComponentMaxInlineDeclarationsRule
ComponentMetadata
ComponentSelectorRule
ContextualDecoratorRule
ContextualLifecycleRule
DirectiveClassSuffixRule
DirectiveMetadata
DirectiveSelectorRule
ImportDestructuringSpacingRule
InjectableMetadata
ModuleMetadata
- controller
- decorator
NgWalker
NoAttributeDecoratorRule
NoConflictingLifecycleRule
NoForwardRefRule
NoHostMetadataPropertyRule
- FAILURE_STRING
- metadata
NoInputPrefixRule
NoInputRenameRule
NoInputsMetadataPropertyRule
- FAILURE_STRING
- metadata
NoLifecycleCallRule
NoOutputNativeRule
NoOutputOnPrefixRule
NoOutputRenameRule
NoOutputsMetadataPropertyRule
- FAILURE_STRING
- metadata
NoPipeImpureRule
NoQueriesMetadataPropertyRule
- FAILURE_STRING
- metadata
NoUnusedCssRule
- apply()
- metadata
PipeMetadata
PipePrefixRule
PreferInlineDecoratorRule
PreferOnPushComponentChangeDetectionRule
PreferOutputReadonlyRule
RelativeUrlPrefixRule
TemplateAccessibilityAltTextRule
TemplateAccessibilityElementsContentRule
TemplateAccessibilityLabelForVisitor
TemplateAccessibilityTabindexNoPositiveRule
TemplateAccessibilityTableScopeRule
TemplateAccessibilityValidAriaRule
- apply()
- metadata
TemplateBananaInBoxRule
TemplateClickEventsHaveKeyEventsRule
TemplateConditionalComplexityRule
TemplateCyclomaticComplexityRule
TemplateI18nRule
TemplateMouseEventsHaveKeyEventsRule
TemplateNoAnyRule
TemplateNoAutofocusRule
TemplateNoCallExpressionRule
TemplateNoDistractingElementsRule
TemplateNoNegatedAsyncRule
TemplateUseTrackByFunctionRule
UseComponentSelectorRule
UseComponentViewEncapsulationRule
UseInjectableProvidedInRule
UseLifecycleInterfaceRule
UsePipeDecoratorRule
UsePipeTransformInterfaceRule

Variables

variable Config

const Config: Config;

variable LogLevel

const LogLevel: { Debug: number; Error: number; Info: number; None: number };

variable rulesDirectory

const rulesDirectory: string;

Classes

class AngularWhitespaceRule

class Rule extends Lint.Rules.AbstractRule {}

property metadata

static readonly metadata: Lint.IRuleMetadata;

method apply

apply: (sourceFile: ts.SourceFile) => Lint.RuleFailure[];

method isEnabled

isEnabled: () => boolean;

class BasicCssAstVisitor

class BasicCssAstVisitor extends SourceMappingVisitor implements ast.CssAstVisitor {}

constructor

constructor(
    sourceFile: ts.SourceFile,
    _originalOptions: Lint.IOptions,
    context: ComponentMetadata,
    style: StyleMetadata,
    templateStart: number
);

property context

protected context: ComponentMetadata;

property templateStart

protected templateStart: number;

method visitCssAtRulePredicate

visitCssAtRulePredicate: (ast: ast.CssAtRulePredicateAst, context?: any) => any;

method visitCssBlock

visitCssBlock: (ast: ast.CssBlockAst, context?: any) => any;

method visitCssDefinition

visitCssDefinition: (ast: ast.CssDefinitionAst, context?: any) => any;

method visitCssInlineRule

visitCssInlineRule: (ast: ast.CssInlineRuleAst, context?: any) => any;

method visitCssKeyframeDefinition

visitCssKeyframeDefinition: (
    ast: ast.CssKeyframeDefinitionAst,
    context?: any
) => any;

method visitCssKeyframeRule

visitCssKeyframeRule: (ast: ast.CssKeyframeRuleAst, context?: any) => any;

method visitCssMediaQueryRule

visitCssMediaQueryRule: (ast: ast.CssMediaQueryRuleAst, context?: any) => any;

method visitCssPseudoSelector

visitCssPseudoSelector: (ast: ast.CssPseudoSelectorAst, context?: any) => any;

method visitCssSelector

visitCssSelector: (ast: ast.CssSelectorAst, context?: any) => any;

method visitCssSelectorRule

visitCssSelectorRule: (ast: ast.CssSelectorRuleAst, context?: any) => any;

method visitCssSimpleSelector

visitCssSimpleSelector: (ast: ast.CssSimpleSelectorAst, context?: any) => any;

method visitCssStylesBlock

visitCssStylesBlock: (ast: ast.CssStylesBlockAst, context?: any) => any;

method visitCssStyleSheet

visitCssStyleSheet: (ast: ast.CssStyleSheetAst, context?: any) => any;

method visitCssUnknownRule

visitCssUnknownRule: (ast: ast.CssUnknownRuleAst, context?: any) => any;

method visitCssUnknownTokenList

visitCssUnknownTokenList: (
    ast: ast.CssUnknownTokenListAst,
    context?: any
) => any;

method visitCssValue

visitCssValue: (ast: ast.CssStyleValueAst, context?: any) => any;

class BasicTemplateAstVisitor

class BasicTemplateAstVisitor
    extends SourceMappingVisitor
    implements ast.TemplateAstVisitor {}

constructor

constructor(
    sourceFile: ts.SourceFile,
    _originalOptions: Lint.IOptions,
    context: ComponentMetadata,
    templateStart: number,
    expressionVisitorCtrl?: RecursiveAngularExpressionVisitorCtr
);

property context

protected context: ComponentMetadata;

property templateStart

protected templateStart: number;

method visit

visit: (node: ast.TemplateAst, context: any) => any;

method visitAttr

visitAttr: (ast: ast.AttrAst, context: any) => any;

method visitBoundText

visitBoundText: (text: ast.BoundTextAst, context: any) => any;

method visitDirective

visitDirective: (ast: ast.DirectiveAst, context: any) => any;

method visitDirectiveProperty

visitDirectiveProperty: (
    prop: ast.BoundDirectivePropertyAst,
    context: any
) => any;

method visitElement

visitElement: (element: ast.ElementAst, context: any) => any;

method visitElementProperty

visitElementProperty: (prop: ast.BoundElementPropertyAst, context: any) => any;

method visitEmbeddedTemplate

visitEmbeddedTemplate: (ast: ast.EmbeddedTemplateAst, context: any) => any;

method visitEvent

visitEvent: (ast: ast.BoundEventAst, context: any) => any;

method visitNgContent

visitNgContent: (ast: ast.NgContentAst, context: any) => any;

method visitNgTemplateAST

protected visitNgTemplateAST: (
    ast: e.AST,
    templateStart: number,
    prop?: any
) => void;

method visitReference

visitReference: (ast: ast.ReferenceAst, context: any) => any;

method visitText

visitText: (text: ast.TextAst, context: any) => any;

method visitVariable

visitVariable: (ast: ast.VariableAst, context: any) => any;

class ComponentClassSuffixRule

class Rule extends Lint.Rules.AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: Lint.IRuleMetadata;

property walkerBuilder

static walkerBuilder: F2<ts.SourceFile, Lint.IOptions, NgWalker>;

method apply

apply: (sourceFile: ts.SourceFile) => Lint.RuleFailure[];

method validate

static validate: (className: string, suffixList: string[]) => boolean;

class ComponentMaxInlineDeclarationsRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

method isEnabled

isEnabled: () => boolean;

class ComponentMetadata

class ComponentMetadata extends DirectiveMetadata {}

constructor

constructor(
    controller: ts.ClassDeclaration,
    decorator: ts.Decorator,
    selector?: string,
    animations?: AnimationMetadata[],
    styles?: StyleMetadata[],
    template?: TemplateMetadata
);

property animations

readonly animations?: AnimationMetadata[];

property controller

readonly controller: ts.ClassDeclaration;

property decorator

readonly decorator: ts.Decorator;

property selector

readonly selector?: string;

property styles

readonly styles?: StyleMetadata[];

property template

readonly template?: TemplateMetadata;

class ComponentSelectorRule

class Rule extends SelectorPropertyBase {}

property handleType

handleType: string;

property metadata

static readonly metadata: IRuleMetadata;

method getPrefixFailure

getPrefixFailure: (prefixes: ReadonlyArray<string>) => string;

method getStyleFailure

getStyleFailure: (style: SelectorStyle) => string;

method getTypeFailure

getTypeFailure: (types: ReadonlyArray<SelectorType>) => string;

method isEnabled

isEnabled: () => boolean;

class ContextualDecoratorRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class ContextualLifecycleRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class DirectiveClassSuffixRule

class Rule extends Lint.Rules.AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: Lint.IRuleMetadata;

method apply

apply: (sourceFile: ts.SourceFile) => Lint.RuleFailure[];

method validate

static validate: (className: string, suffixes: string[]) => boolean;

class DirectiveMetadata

class DirectiveMetadata {}

constructor

constructor(
    controller: ts.ClassDeclaration,
    decorator: ts.Decorator,
    selector?: string
);

property controller

readonly controller: ts.ClassDeclaration;

property decorator

readonly decorator: ts.Decorator;

property selector

readonly selector?: string;

class DirectiveSelectorRule

class Rule extends SelectorPropertyBase {}

property handleType

handleType: string;

property metadata

static readonly metadata: IRuleMetadata;

method getPrefixFailure

getPrefixFailure: (prefixes: ReadonlyArray<string>) => string;

method getStyleFailure

getStyleFailure: (style: SelectorStyle) => string;

method getTypeFailure

getTypeFailure: (types: ReadonlyArray<SelectorType>) => string;

method isEnabled

isEnabled: () => boolean;

class ImportDestructuringSpacingRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class InjectableMetadata

class InjectableMetadata {}

constructor

constructor(
    controller: ts.ClassDeclaration,
    decorator: ts.Decorator,
    providedIn?: any
);

property controller

readonly controller: ts.ClassDeclaration;

property decorator

readonly decorator: ts.Decorator;

property providedIn

readonly providedIn?: any;

class ModuleMetadata

class ModuleMetadata {}

constructor

constructor(controller: ts.ClassDeclaration, decorator: ts.Decorator);

property controller

readonly controller: ts.ClassDeclaration;

property decorator

readonly decorator: ts.Decorator;

class NgWalker

class NgWalker extends Lint.RuleWalker {}

constructor

constructor(
    sourceFile: ts.SourceFile,
    _originalOptions: Lint.IOptions,
    _config?: NgWalkerConfig,
    _metadataReader?: MetadataReader
);

method getContextSourceFile

protected getContextSourceFile: (path: string, content: string) => ts.SourceFile;

method visitClassDeclaration

visitClassDeclaration: (declaration: ts.ClassDeclaration) => void;

method visitClassDecorator

protected visitClassDecorator: (decorator: ts.Decorator) => void;

method visitMethodDeclaration

visitMethodDeclaration: (method: ts.MethodDeclaration) => void;

method visitMethodDecorator

protected visitMethodDecorator: (decorator: ts.Decorator) => void;

method visitNgComponent

protected visitNgComponent: (metadata: ComponentMetadata) => void;

method visitNgContentChild

protected visitNgContentChild: (
    property: ts.PropertyDeclaration,
    input: ts.Decorator,
    args: string[]
) => void;

method visitNgContentChildren

protected visitNgContentChildren: (
    property: ts.PropertyDeclaration,
    input: ts.Decorator,
    args: string[]
) => void;

method visitNgDirective

protected visitNgDirective: (metadata: DirectiveMetadata) => void;

method visitNgHostBinding

protected visitNgHostBinding: (
    property: ts.PropertyDeclaration,
    decorator: ts.Decorator,
    args: string[]
) => void;

method visitNgHostListener

protected visitNgHostListener: (
    method: ts.MethodDeclaration,
    decorator: ts.Decorator,
    args: string[]
) => void;

method visitNgInjectable

protected visitNgInjectable: (metadata: InjectableMetadata) => void;

method visitNgInput

protected visitNgInput: (
    property: ts.PropertyDeclaration,
    input: ts.Decorator,
    args: string[]
) => void;

method visitNgModule

protected visitNgModule: (metadata: ModuleMetadata) => void;

method visitNgOutput

protected visitNgOutput: (
    property: ts.PropertyDeclaration,
    output: ts.Decorator,
    args: string[]
) => void;

method visitNgPipe

protected visitNgPipe: (metadata: PipeMetadata) => void;

method visitNgStyleHelper

protected visitNgStyleHelper: (
    style: CssAst,
    context: ComponentMetadata,
    styleMetadata: StyleMetadata,
    baseStart: number
) => void;

method visitNgTemplateHelper

protected visitNgTemplateHelper: (
    roots: compiler.TemplateAst[],
    context: ComponentMetadata,
    baseStart: number
) => void;

method visitNgViewChild

protected visitNgViewChild: (
    property: ts.PropertyDeclaration,
    input: ts.Decorator,
    args: string[]
) => void;

method visitNgViewChildren

protected visitNgViewChildren: (
    property: ts.PropertyDeclaration,
    input: ts.Decorator,
    args: string[]
) => void;

method visitPropertyDeclaration

visitPropertyDeclaration: (prop: ts.PropertyDeclaration) => void;

method visitPropertyDecorator

protected visitPropertyDecorator: (decorator: ts.Decorator) => void;

class NoAttributeDecoratorRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class NoConflictingLifecycleRule

class Rule extends AbstractRule {}

property FAILURE_STRING_INTERFACE_HOOK

static readonly FAILURE_STRING_INTERFACE_HOOK: string;

property FAILURE_STRING_METHOD_HOOK

static readonly FAILURE_STRING_METHOD_HOOK: string;

property metadata

static metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class NoForwardRefRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class NoHostMetadataPropertyRule

class Rule extends MetadataPropertyBase {}

constructor

constructor(options: IOptions);

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

class NoInputPrefixRule

class Rule extends Rules.AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

method isEnabled

isEnabled: () => boolean;

class NoInputRenameRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class NoInputsMetadataPropertyRule

class Rule extends MetadataPropertyBase {}

constructor

constructor(options: IOptions);

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

class NoLifecycleCallRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class NoOutputNativeRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class NoOutputOnPrefixRule

class Rule extends Lint.Rules.AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: Lint.IRuleMetadata;

method apply

apply: (sourceFile: ts.SourceFile) => Lint.RuleFailure[];

class NoOutputRenameRule

class Rule extends Rules.AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class NoOutputsMetadataPropertyRule

class Rule extends MetadataPropertyBase {}

constructor

constructor(options: IOptions);

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

class NoPipeImpureRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class NoQueriesMetadataPropertyRule

class Rule extends MetadataPropertyBase {}

constructor

constructor(options: IOptions);

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

class NoUnusedCssRule

class Rule extends Lint.Rules.AbstractRule {}

property metadata

static readonly metadata: Lint.IRuleMetadata;

method apply

apply: (sourceFile: ts.SourceFile) => Lint.RuleFailure[];

class PipeMetadata

class PipeMetadata {}

constructor

constructor(
    controller: ts.ClassDeclaration,
    decorator: ts.Decorator,
    name?: string,
    pure?: ts.BooleanLiteral
);

property controller

readonly controller: ts.ClassDeclaration;

property decorator

readonly decorator: ts.Decorator;

property name

readonly name?: string;

property pure

readonly pure?: ts.BooleanLiteral;

class PipePrefixRule

class Rule extends Lint.Rules.AbstractRule {}

constructor

constructor(options: Lint.IOptions);

property FAILURE_STRING

static FAILURE_STRING: string;

property metadata

static readonly metadata: Lint.IRuleMetadata;

property prefix

prefix: string;

method apply

apply: (sourceFile: ts.SourceFile) => Lint.RuleFailure[];

method isEnabled

isEnabled: () => boolean;

method validatePrefix

validatePrefix: (prefix: string) => boolean;

class PreferInlineDecoratorRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

method isEnabled

isEnabled: () => boolean;

class PreferOnPushComponentChangeDetectionRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class PreferOutputReadonlyRule

class Rule extends Rules.AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class RelativeUrlPrefixRule

class Rule extends Rules.AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class TemplateAccessibilityAltTextRule

class Rule extends Rules.AbstractRule {}

property DEFAULT_ELEMENTS

static readonly DEFAULT_ELEMENTS: string[];

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class TemplateAccessibilityElementsContentRule

class Rule extends Rules.AbstractRule {}

property ELEMENTS

static readonly ELEMENTS: string[];

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class TemplateAccessibilityLabelForVisitor

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

method isEnabled

isEnabled: () => boolean;

class TemplateAccessibilityTabindexNoPositiveRule

class Rule extends Rules.AbstractRule {}

property FAILURE_MESSAGE

static readonly FAILURE_MESSAGE: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class TemplateAccessibilityTableScopeRule

class Rule extends Rules.AbstractRule {}

property FAILURE_MESSAGE

static readonly FAILURE_MESSAGE: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class TemplateAccessibilityValidAriaRule

class Rule extends Rules.AbstractRule {}

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class TemplateBananaInBoxRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class TemplateClickEventsHaveKeyEventsRule

class Rule extends Rules.AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class TemplateConditionalComplexityRule

class Rule extends Rules.AbstractRule {}

property DEFAULT_MAX_COMPLEXITY

static readonly DEFAULT_MAX_COMPLEXITY: number;

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

method isEnabled

isEnabled: () => boolean;

class TemplateCyclomaticComplexityRule

class Rule extends Rules.AbstractRule {}

property DEFAULT_MAX_COMPLEXITY

static readonly DEFAULT_MAX_COMPLEXITY: number;

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

method isEnabled

isEnabled: () => boolean;

class TemplateI18nRule

class Rule extends AbstractRule {}

property FAILURE_STRING_ATTR

static readonly FAILURE_STRING_ATTR: string;

property FAILURE_STRING_TEXT

static readonly FAILURE_STRING_TEXT: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

method isEnabled

isEnabled: () => boolean;

class TemplateMouseEventsHaveKeyEventsRule

class Rule extends Rules.AbstractRule {}

property FAILURE_STRING_MOUSE_OUT

static readonly FAILURE_STRING_MOUSE_OUT: string;

property FAILURE_STRING_MOUSE_OVER

static readonly FAILURE_STRING_MOUSE_OVER: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class TemplateNoAnyRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class TemplateNoAutofocusRule

class Rule extends Rules.AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class TemplateNoCallExpressionRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class TemplateNoDistractingElementsRule

class Rule extends Rules.AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class TemplateNoNegatedAsyncRule

class Rule extends AbstractRule {}

property FAILURE_STRING_NEGATED_PIPE

static readonly FAILURE_STRING_NEGATED_PIPE: string;

property FAILURE_STRING_UNSTRICT_EQUALITY

static readonly FAILURE_STRING_UNSTRICT_EQUALITY: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class TemplateUseTrackByFunctionRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class UseComponentSelectorRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class UseComponentViewEncapsulationRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class UseInjectableProvidedInRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class UseLifecycleInterfaceRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class UsePipeDecoratorRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

class UsePipeTransformInterfaceRule

class Rule extends AbstractRule {}

property FAILURE_STRING

static readonly FAILURE_STRING: string;

property metadata

static readonly metadata: IRuleMetadata;

method apply

apply: (sourceFile: SourceFile) => RuleFailure[];

Interfaces

interface AnimationMetadata

interface AnimationMetadata extends PropertyMetadata {}

property animation

animation: CodeWithSourceMap;

interface CodeWithSourceMap

interface CodeWithSourceMap {}

property code

code: string;

property map

map?: RawSourceMap;

property source

source?: string;

interface Config

interface Config {}

property interpolation

interpolation: [string, string];

property logLevel

logLevel: ValueOf<typeof LogLevel>;

property predefinedDirectives

predefinedDirectives: DirectiveDeclaration[];

property resolveUrl

resolveUrl: UrlResolver;

property transformStyle

transformStyle: StyleTransformer;

property transformTemplate

transformTemplate: TemplateTransformer;

interface CssAstVisitorCtrl

interface CssAstVisitorCtrl {}

construct signature

new (
    sourceFile: ts.SourceFile,
    options: Lint.IOptions,
    context: ComponentMetadata,
    style: StyleMetadata,
    templateStart: number
): any;

interface DirectiveDeclaration

interface DirectiveDeclaration {}

property exportAs

exportAs?: string;

property hostAttributes

hostAttributes?: string[];

property hostListeners

hostListeners?: string[];

property hostProperties

hostProperties?: string[];

property inputs

inputs?: string[];

property outputs

outputs?: string[];

property selector

selector: string;

interface NgWalkerConfig

interface NgWalkerConfig {}

property cssVisitorCtrl

cssVisitorCtrl?: CssAstVisitorCtrl;

property expressionVisitorCtrl

expressionVisitorCtrl?: RecursiveAngularExpressionVisitorCtr;

property templateVisitorCtrl

templateVisitorCtrl?: TemplateAstVisitorCtr;

interface PropertyMetadata

interface PropertyMetadata {}

property node

node?: ts.Node;

property url

url?: string;

interface RecursiveAngularExpressionVisitorCtr

interface RecursiveAngularExpressionVisitorCtr {}

construct signature

new (
    sourceFile: ts.SourceFile,
    options: Lint.IOptions,
    context: ComponentMetadata,
    basePosition: number
): any;

interface StyleMetadata

interface StyleMetadata extends PropertyMetadata {}

property style

style: CodeWithSourceMap;

interface StyleTransformer

interface StyleTransformer {}

call signature

(code: string, url?: string): CodeWithSourceMap;

interface TemplateAstVisitorCtr

interface TemplateAstVisitorCtr {}

construct signature

new (
    sourceFile: ts.SourceFile,
    options: Lint.IOptions,
    context: ComponentMetadata,
    templateStart: number,
    expressionVisitorCtrl: RecursiveAngularExpressionVisitorCtr
): any;

interface TemplateMetadata

interface TemplateMetadata extends PropertyMetadata {}

property template

template: CodeWithSourceMap;

interface TemplateTransformer

interface TemplateTransformer {}

call signature

(code: string, url?: string): CodeWithSourceMap;

interface UrlResolver

interface UrlResolver {}

call signature

(url: string | null): string | null;

Package Files (59)

Dependencies (14)

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (3)

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/codelyzer.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/codelyzer)

HTML

<a href="https://www.jsdocs.io/package/codelyzer"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 3 years ago.
Package analyzed in 5128 ms.
Missing or incorrect documentation? Open an issue for this package.