defineAsyncComponent() — vue Function Reference

Architecture documentation for the defineAsyncComponent() function in apiAsyncComponent.ts from the vue codebase.

Function typescript CompilerSFC ScriptAnalyzer calls 1

Entity Profile

CompilerSFC→ ScriptAnalyzer→ defineAsyncComponent() — vue Function Reference

Dependency Diagram

graph TD
  8a7c1af9_a54d_6bbc_f768_5a79cb296d1c["defineAsyncComponent()"]
  bed9af47_0db9_d1c8_3d4e_674cdf4ecb2d["apiAsyncComponent.ts"]
  8a7c1af9_a54d_6bbc_f768_5a79cb296d1c -->|defined in| bed9af47_0db9_d1c8_3d4e_674cdf4ecb2d
  32b84189_dbb9_775d_845a_43a67cffe4a9["Promise()"]
  8a7c1af9_a54d_6bbc_f768_5a79cb296d1c -->|calls| 32b84189_dbb9_775d_845a_43a67cffe4a9
  style 8a7c1af9_a54d_6bbc_f768_5a79cb296d1c fill:#6366f1,stroke:#818cf8,color:#fff

Relationship Graph

Source Code

src/v3/apiAsyncComponent.ts lines 31–117

export function defineAsyncComponent(
  source: (() => any) | AsyncComponentOptions
): AsyncComponentFactory {
  if (isFunction(source)) {
    source = { loader: source } as AsyncComponentOptions
  }

  const {
    loader,
    loadingComponent,
    errorComponent,
    delay = 200,
    timeout, // undefined = never times out
    suspensible = false, // in Vue 3 default is true
    onError: userOnError
  } = source

  if (__DEV__ && suspensible) {
    warn(
      `The suspensible option for async components is not supported in Vue2. It is ignored.`
    )
  }

  let pendingRequest: Promise<any> | null = null

  let retries = 0
  const retry = () => {
    retries++
    pendingRequest = null
    return load()
  }

  const load = (): Promise<any> => {
    let thisRequest: Promise<any>
    return (
      pendingRequest ||
      (thisRequest = pendingRequest =
        loader()
          .catch(err => {
            err = err instanceof Error ? err : new Error(String(err))
            if (userOnError) {
              return new Promise((resolve, reject) => {
                const userRetry = () => resolve(retry())
                const userFail = () => reject(err)
                userOnError(err, userRetry, userFail, retries + 1)
              })
            } else {
              throw err
            }
          })
          .then((comp: any) => {
            if (thisRequest !== pendingRequest && pendingRequest) {
              return pendingRequest
            }
            if (__DEV__ && !comp) {
              warn(
                `Async component loader resolved to undefined. ` +
                  `If you are using retry(), make sure to return its return value.`
              )
            }
            // interop module default
            if (
              comp &&
              (comp.__esModule || comp[Symbol.toStringTag] === 'Module')
            ) {
              comp = comp.default
            }
            if (__DEV__ && comp && !isObject(comp) && !isFunction(comp)) {
              throw new Error(`Invalid async component load result: ${comp}`)
            }
            return comp
          }))
    )
  }

  return () => {
    const component = load()

    return {
      component,
      delay,