第五章：createElement

const SIMPLE_NORMALIZE = 1
const ALWAYS_NORMALIZE = 2

export function createElement (
  context: Component, // vm实例
  tag: any, // 标签
  data: any, // 数据
  children: any, // 子节点，构造tree
  normalizationType: any,
  alwaysNormalize: boolean
): VNode | Array<VNode> {
  // 参数“重载”，对参数个数不一致的处理
  if (Array.isArray(data) || isPrimitive(data)) {
    normalizationType = children
    children = data
    data = undefined
  }
  if (isTrue(alwaysNormalize)) {
    normalizationType = ALWAYS_NORMALIZE
  }
  return _createElement(context, tag, data, children, normalizationType)
}

export function _createElement (
  context: Component,
  tag?: string | Class<Component> | Function | Object,
  data?: VNodeData,
  children?: any,
  normalizationType?: number
): VNode | Array<VNode> {
  // 对data进行判断，参数有问题就会返回 createEmptyVNode() 生成的空 VNode

  // 不允许data是响应式的
  if (isDef(data) && isDef((data: any).__ob__)) {
    process.env.NODE_ENV !== 'production' && warn(
      `Avoid using observed data object as vnode data: ${JSON.stringify(data)}
` +
      'Always create fresh vnode data objects in each render!',
      context
    )
    return createEmptyVNode()
  }
  // 比如在<component :is>会有这个属性
  if (isDef(data) && isDef(data.is)) {
    tag = data.is
  }
  if (!tag) {
    // 防止 component :is 设置为 falsy 
    return createEmptyVNode()
  }

  // ... 省略代码 ...

  // 处理children，判断多种情况，最终返回一个一维的VNode数组
  if (normalizationType === ALWAYS_NORMALIZE) {
    children = normalizeChildren(children)
  } else if (normalizationType === SIMPLE_NORMALIZE) {
    children = simpleNormalizeChildren(children)
  }
  let vnode, ns
  if (typeof tag === 'string') {
    let Ctor
    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag)
    // 是否是保留标签 比如 div
    if (config.isReservedTag(tag)) {
      // 平台内置的元素
      vnode = new VNode(
        config.parsePlatformTagName(tag), data, children,
        undefined, undefined, context
      )
    } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
      // ... 省略代码 ...

    } else {
      // ... 省略代码 ...

  } else {
      // ... 省略代码 ...
  }

  // ... 省略代码 ...

}

vnode = new VNode(
        config.parsePlatformTagName(tag), data, children,
        undefined, undefined, context

export function simpleNormalizeChildren (children: any) {
  for (let i = 0; i < children.length; i++) {
    // 将数组中的嵌套数组拍平成一维数组，因为可能会有“函数式组件”
    // 只考虑一级的情况
    if (Array.isArray(children[i])) {
      return Array.prototype.concat.apply([], children)
    }
  }
  return children
}

export function normalizeChildren (children: any): ?Array<VNode> {
  // 如果是基础类型，就加到数组里，设置为TextNode
  return isPrimitive(children)
    ? [createTextVNode(children)]
    : Array.isArray(children)
      ? normalizeArrayChildren(children)
      : undefined
}

// 递归，最终将children拍平为一维VNode数组
function normalizeArrayChildren (children: any, nestedIndex?: string): Array<VNode> {
  const res = []
  let i, c, lastIndex, last
  for (i = 0; i < children.length; i++) {
    c = children[i]
    if (isUndef(c) || typeof c === 'boolean') continue
    lastIndex = res.length - 1
    last = res[lastIndex]
    //  nested，如果是嵌套的，就进行递归
    // 比如<template>, <slot>, v-for
    if (Array.isArray(c)) {
      if (c.length > 0) {
        c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`)
        // 优化：可能最后一个处理节点和下次要处理的第一个节点都是文本，那么就可以合并到一起
        if (isTextNode(c[0]) && isTextNode(last)) {
          res[lastIndex] = createTextVNode(last.text + (c[0]: any).text)
          c.shift()
        }
        res.push.apply(res, c)
      }
    } else if (isPrimitive(c)) {
      // 如果是基础类型
      if (isTextNode(last)) {
        res[lastIndex] = createTextVNode(last.text + c)
      } else if (c !== '') {
        res.push(createTextVNode(c))
      }
    } else {
      // ... 省略代码 ...
    }
  }
  return res
}

new Vue({
  el: '#app',
  data() {
    return {
      name: 'Vinsea'
    }
  },
})