find-vue-components.js

// @flow
import { FUNCTIONAL_OPTIONS, VUE_VERSION } from './consts'
import { throwError } from 'shared/util'

export function findAllVueComponentsFromVm (
  vm: Component,
  components: Array<Component> = []
): Array<Component> {
  components.push(vm)
  vm.$children.forEach(child => {
    findAllVueComponentsFromVm(child, components)
  })

  return components
}

function findAllVueComponentsFromVnode (
  vnode: Component,
  components: Array<Component> = []
): Array<Component> {
  if (vnode.child) {
    components.push(vnode.child)
  }
  if (vnode.children) {
    vnode.children.forEach(child => {
      findAllVueComponentsFromVnode(child, components)
    })
  }

  return components
}

function findAllFunctionalComponentsFromVnode (
  vnode: Component,
  components: Array<Component> = []
): Array<Component> {
  if (vnode[FUNCTIONAL_OPTIONS] || vnode.functionalContext) {
    components.push(vnode)
  }
  if (vnode.children) {
    vnode.children.forEach(child => {
      findAllFunctionalComponentsFromVnode(child, components)
    })
  }
  return components
}

export function vmCtorMatchesName (vm: Component, name: string): boolean {
  return !!(
    name && (
      (vm._vnode &&
      vm._vnode.functionalOptions &&
      vm._vnode.functionalOptions.name === name) ||
    (vm.$options && vm.$options.name === name) ||
    (vm.options && vm.options.name === name)
    ))
}

export function vmCtorMatchesSelector (
  component: Component,
  selector: Object
): boolean {
  const Ctor = selector._Ctor || (selector.options && selector.options._Ctor)
  if (!Ctor) {
    return false
  }
  const constructor = component.__proto__.constructor
  return Object.keys(Ctor || {}).some(c => {
    return Ctor[c] === constructor || Ctor[c] === constructor.super
  })
}

export function vmFunctionalCtorMatchesSelector (
  component: VNode,
  Ctor: Object
): boolean {
  if (VUE_VERSION < 2.3) {
    throwError(
      `find for functional components is not supported in ` + `Vue < 2.3`
    )
  }

  if (!Ctor) {
    return false
  }

  if (!component[FUNCTIONAL_OPTIONS]) {
    return false
  }
  const Ctors = Object.keys(component[FUNCTIONAL_OPTIONS]._Ctor)
  return Ctors.some(c => Ctor[c] === component[FUNCTIONAL_OPTIONS]._Ctor[c])
}

function findComponentsByTag (
  selector: string,
  components: Array<Component> = []
): Array<Component> {
  return components.filter(component =>
    component.$options._componentTag === selector
  )
}

export default function findVueComponents (
  root: Component,
  selectorType: ?string,
  selector: Object
): Array<Component> {
  if (selector.functional) {
    const nodes = root._vnode
      ? findAllFunctionalComponentsFromVnode(root._vnode)
      : findAllFunctionalComponentsFromVnode(root)
    return nodes.filter(
      node =>
        vmFunctionalCtorMatchesSelector(node, selector._Ctor) ||
        node[FUNCTIONAL_OPTIONS].name === selector.name
    )
  }
  const nameSelector =
    typeof selector === 'function' ? selector.extendOptions.name : selector.name
  const components = root._isVue
    ? findAllVueComponentsFromVm(root)
    : findAllVueComponentsFromVnode(root)

  if (typeof selector === 'string') {
    const componentsWithMatchingTag = findComponentsByTag(selector, components)
    if (componentsWithMatchingTag.length > 0) {
      return componentsWithMatchingTag
    }
  }

  return components.filter(component => {
    if (!component.$vnode && !component.$options.extends) {
      return false
    }
    return (
      vmCtorMatchesSelector(component, selector) ||
      vmCtorMatchesName(component, nameSelector)
    )
  })
}