@vuedx/analyze

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

More info

Signature:

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
}

Members:

refresh

Signature:

protected refresh(): void;

setFileNames

Signature:

setFileNames(fileNames: string[]): void;

Parameter	Type	Description
fileNames	string[]	-

InferredVueProject

More info

Signature:

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

Members:

refresh

Signature:

protected refresh(): void;

VueProject

More info

Signature:

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[]
}

Members:

loadGlobalComponents

Signature:

protected loadGlobalComponents(): void;

markDirty

Signature:

markDirty(): void;

refresh

Signature:

protected abstract refresh(): void;

reloadIfNeeded

Signature:

protected reloadIfNeeded(): void;

setConfig

Signature:

setConfig(config: ProjectConfig): void;

Parameter	Type	Description
config	ProjectConfig	-

setFileNames

Signature:

setFileNames(fileNames: string[]): void;

Parameter	Type	Description
fileNames	string[]	-

createAnalyzer

More info

Signature:

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

Parameter	Type	Description
plugins	Plugin[]	-
options	Partial<Context['parsers']>	-

createFullAnalyzer

More info

Signature:

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

Parameter	Type	Description
plugins	Plugin[]	-
options	Partial<Context['parsers']>	-

createSourceRange

More info

Signature:

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

Parameter	Type	Description
context	Context | ScriptAnalyzerContext	-
node	Node	-

transformToFunction

More info

Signature:

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

Parameter	Type	Description
content	string	-
options	FunctionTransformOptions	-

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 {
  components: LocalComponentRegistrationInfo[]
  emits: EmitInfo[]
  errors: SyntaxError[]
  fnSetupOption?: SetupInfo
  identifierSource: Record<string, IdentifierSource>
  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
}