Analyze

A tool to statically analyze Vue single file components.

Support

This package is part of VueDX project, maintained by Rahul Kadyan. You can 💖 sponsor him for continued development of this package and other VueDX tools.

Usage

API

ConfiguredVueProject

declare class ConfiguredVueProject extends VueProject {
  constructor(rootDir: string, packageFile: string | undefined, packageJSON: Partial<PackageJSON>, configFile: string, config: Readonly<ProjectConfig>, requireModule?: NodeJS.Require);
  readonly configFile: string;
  kind: "configured";
  protected refresh(): void;
  setFileNames(fileNames: string[]): void;
}

protected refresh(): void;

setFileNames(fileNames: string[]): void;

InferredVueProject

declare class InferredVueProject extends VueProject {
  kind: "inferred";
  protected refresh(): void;
}

protected refresh(): void;

VueProject

declare abstract class VueProject {
  protected _config: Readonly<ProjectConfigNormalized>;
  protected _externalComponents: ComponentRegistrationInfo[];
  protected _fileNames: string[];
  protected _globalComponents: ComponentRegistrationInfo[];
  protected _projectComponents: Map<string, ComponentRegistrationInfo[]>;
  protected _version: string;
  constructor(rootDir: string, packageFile: string | undefined, packageJSON: Partial<PackageJSON>, requireModule?: NodeJS.Require);
  get components(): ComponentRegistrationInfo[];
  get config(): Readonly<ProjectConfigNormalized>;
  get fileNames(): string[];
  get globalComponents(): ComponentRegistrationInfo[];
  protected isDirty: boolean;
  abstract kind: 'inferred' | 'configured';
  protected loadGlobalComponents(): void;
  markDirty(): void;
  readonly packageFile: string | undefined;
  packageJSON: PackageJSON;
  protected abstract refresh(): void;
  protected reloadIfNeeded(): void;
  protected readonly requireModule: NodeJS.Require;
  readonly rootDir: string;
  setConfig(config: ProjectConfig): void;
  setFileNames(fileNames: string[]): void;
  get version(): string;
  get vueFileNames(): string[];
}

protected loadGlobalComponents(): void;

markDirty(): void;

protected abstract refresh(): void;

protected reloadIfNeeded(): void;

setConfig(config: ProjectConfig): void;

setFileNames(fileNames: string[]): void;

createAnalyzer

declare function createAnalyzer(plugins: Plugin[], options?: Partial<Context['parsers']>): Analyzer;

createFullAnalyzer

declare function createFullAnalyzer(plugins?: Plugin[], options?: Partial<Context['parsers']>): ReturnType<typeof createAnalyzer>;

createSourceRange

declare function createSourceRange(context: Context | ScriptAnalyzerContext, node: Node): SourceRange;

toVeturData

declare function toVeturData(components: ComponentInfo[]): VeturData;

toWebTypes

declare function toWebTypes(name: string, version: string, components: ComponentInfo[]): WebTypes;

transformToFunction

declare function transformToFunction(content: string, options?: FunctionTransformOptions): string;

Types

Analyzer

interface Analyzer {
  analyze(content: string, fileName?: string): ComponentInfo;
  analyzeScript(content: string, fileName?: string, mode?: 'script' | 'scriptSetup'): ComponentInfo;
  analyzeTemplate(content: string, fileName?: string): ComponentInfo;
}

ComponentInfo

interface ComponentInfo extends Taggable {
  aliases: string[];
  components: LocalComponentRegistrationInfo[];
  description: string;
  emits: EmitInfo[];
  errors: SyntaxError[];
  fileName: string;
  fnSetupOption?: SetupInfo;
  identifierSource: Record<string, IdentifierSource>;
  name: string;
  options?: ComponentOptionsInfo;
  props: PropInfo[];
  scriptSetup?: ScriptSetupInfo;
}

ComponentRegistrationInfo

interface ComponentRegistrationInfo {
  aliases: string[];
  name: string;
  source: ImportSource;
}

EmitInfo

interface EmitInfo extends Taggable, Addressable {
  description: string;
  isDynamic: boolean;
  isInferred: boolean;
  name: string;
  references: SourceRange[];
  type: TypeInfo[];
}

IdentifierSource

interface IdentifierSource extends Addressable {
  name: string;
}

ImportSource

interface ImportSource {
  exportName?: string;
  localName: string;
  moduleName: string;
}

ImportSourceWithLocation

interface ImportSourceWithLocation extends ImportSource, Addressable {
}

LocalComponentRegistrationInfo

interface LocalComponentRegistrationInfo extends ComponentRegistrationInfo, Addressable {
  kind: 'script' | 'scriptSetup';
  source: ImportSourceWithLocation;
}

Plugin

interface Plugin {
  babel?: AbstractScriptAnalyzerFn | AbstractAnalyzerHandler;
  blocks?: Partial<{
        script: BlockAnalyzer<SFCScriptBlock>;
        template: BlockAnalyzer<SFCTemplateBlock>;
        style: BlockAnalyzer<SFCStyleBlock>;
    }> & Record<string, BlockAnalyzer<any>>;
  declaration?: ComponentDeclarationAnalyzer[];
  options?: ComponentOptionsAnalyzer[] | Record<string, AbstractScriptAnalyzerFn<ObjectMember>>;
  setup?: ComponentSetupFnAnalyzer[];
  templateExpression?(node: File, context: Context): void;
}

PropInfo

interface PropInfo extends Taggable, Addressable {
  defaultValue: ValueInfo | null;
  description: string;
  name: string;
  required: boolean;
  type: TypeInfo[];
}

ScriptSetupInfo

interface ScriptSetupInfo {
  defineEmit?: Addressable;
  defineProps?: Addressable;
}

SetupInfo

interface SetupInfo extends Addressable {
  context?: {
        identifiers: Partial<{
            attrs: string;
            slots: string;
            emit: string;
        }>;
        rest?: string;
    } & Addressable;
  props?: {
        identifiers: string[];
        rest?: string;
    } & Addressable;
  return?: Addressable;
}

SourceRange

interface SourceRange {
  end: SourceLocation;
  source: string;
  start: SourceLocation;
}

SyntaxError

interface SyntaxError {
  loc: SourceLocation;
  message: string;
}

VeturData

interface VeturData {
  attributes: Record<string, {
        type: string;
        description: string;
    }>;
  tags: Record<string, {
        description: string;
        attributes: string[];
    }>;
}

WebTypes

interface WebTypes {
  contributions: {
        'types-syntax': 'typescript';
        'description-markup': 'html' | 'markdown' | 'none';
        tags: Tag[];
        attributes: Attribute[];
    };
  framework: 'vue';
  name: string;
  version: string;
}