/* @flow */
function square (num) {  
    return num * num
}
square('2')

var someData = {
    id: 1,
    text: '选项1'
}

/* /decls/data.js.flow */
declare type SomeData = {
  id: number;
  text: string;
}

Vue.extend( options ) // 传入一个配置对象，生成新的组件构造函数
Vue.set( target, key, value ) // 设置对象属性
Vue.delete( target, key ) // 删除对象的属性
Vue.nextTick( [callback, context] ) // 在下次 DOM 更新循环结束之后执行回调函数
Vue.use( plugin ) // 安装 Vue.js 插件
Vue.mixin( mixin ) // 全局注册一个混入，影响之后创建的每一个 Vue 实例
Vue.compile( template ) // 将字符串模板编译成渲染函数

Vue.directive( id, [definition] ) // 注册或获取全局指令（两个实参注册，一个实参获取）
Vue.component( id, [definition] ) // 注册或获取全局组件（两个实参注册，一个实参获取）
Vue.filter( id, [definition] ) // 注册或获取全局过滤器（两个实参注册，一个实参获取）

Vue.prototype.$data // vm.$data -> vm._data -> vm.$options.data
Vue.prototype.$props // vm.$props -> vm._props -> vm.$options.props
Vue.prototype.$set // 设置对象属性，这是全局 Vue.set 方法的别名
Vue.prototype.$delete // 删除对象属性，这是全局 Vue.delete 方法的别名
Vue.prototype.$watch // 观察一个函数返回值/表达式的值，若发生变化就触发回调函数

Vue.prototype.$on // 监听自定义事件
Vue.prototype.$once // 监听自定义事件（只触发一次，然后自动解除监听）
Vue.prototype.$off // 移除自定义事件监听器
Vue.prototype.$emit // 触发事件

Vue.prototype._update // 更新视图（内部方法）
Vue.prototype.$forceUpdate // 更新视图（实际上就是调用上面的 _update 方法）
Vue.prototype.$destroy // 完全销毁一个实例。清理它与其它实例的连接，解绑它的全部指令及事件监听器

Vue.prototype.$nextTick // 将回调函数延迟到下次 DOM 更新循环之后执行（它跟全局方法 Vue.nextTick 一样，不同的是回调的 this 自动绑定到调用它的实例上）
Vue.prototype._render // 生成当前实例对应的虚拟节点 vnode
Vue.prototype._o = markOnce // 标记静态树（v-once）
Vue.prototype._n = toNumber // 转为数值
Vue.prototype._s = toString // 转为字符串
Vue.prototype._l = renderList // 渲染 v-for 列表
Vue.prototype._t = renderSlot // 渲染 <slot>
Vue.prototype._q = looseEqual // 形式上（都转为字符串后）是否相等
Vue.prototype._i = looseIndexOf // 返回元素在数组中的索引
Vue.prototype._m = renderStatic // 渲染静态树
Vue.prototype._f = resolveFilter // 根据 id 返回某个指定的过滤器
Vue.prototype._k = checkKeyCodes // 检查当前按下的键盘按键，若不是指定的键，则返回 true
Vue.prototype._b = bindObjectProps // 将 v-bind="object" 转换成 VNode 的 data
Vue.prototype._v = createTextVNode // 创建文本 VNode
Vue.prototype._e = createEmptyVNode // 创建一个空的 vNode（注释）
Vue.prototype._u = resolveScopedSlots // 返回作用域插槽渲染函数集合
Vue.prototype._g = bindObjectListeners // 将 v-on="object" 转换成 VNode 的 data

observe(data, true /* 作为根 data */)

var watcher = new Watcher(vm, 'aaa.bbb.ccc' , cb, options);

warn(msg, vm) // 打印警告信息
tip(msg, vm) // 打印提示信息
formatComponentName(vm, includeFile) // 返回格式化的字符串形式组件名

var callbacks = [];
var pending = false;
var timerFunc;

function nextTickHandler () {
    /* 依次执行 callbacks 队列中的函数，并清空该队列，解锁 */
}
timerFunc = function () {
    /* 异步执行 nextTickHandler() */
};
var nextTick = function queueNextTick (cb, ctx) {
    var _resolve;
    /* 将匿名函数封装 cb/_resolve，并推入 callbacks 队列 */
    callbacks.push(function () {
      if (cb) {
        cb.call(ctx);
      } else if (_resolve) {
        _resolve(ctx);
      }
    });
    /* 执行 timerFunc() 并上锁 */
    if (!pending) {
      pending = true;
      timerFunc();
    }
    /* 参数为空并且不支持 Promise */
    if (!cb && typeof Promise !== 'undefined') {
      return new Promise(function (resolve, reject) {
        /* 于是可以用 _resolve 方法来触发 Promise 实例的 then 回调 */
        _resolve = resolve;
      })
    }
}

var nextTick = function queueNextTick (cb, ctx) {...}

// 1. 初始化合并策略对象
config.optionMergeStrategies = Object.create(null)
strats = config.optionMergeStrategies

// 2. 逐步添加各个选项的合并策略
strats.el = strats.propsData = function (parent, child, vm, key) {...}
strats.data = function (parentVal, childVal, vm) {...}

[
  'beforeCreate',
  'created',
  'beforeMount',
  'mounted',
  'beforeUpdate',
  'updated',
  'beforeDestroy',
  'destroyed',
  'activated',
  'deactivated'
].forEach(hook => {
  strats[hook] = mergeHook
})

[
 'component',
 'directive',
 'filter'
].forEach(function (type) {
  strats[type + 's'] = mergeAssets
})

strats.watch = function (parentVal, childVal) {...}

strats.props =
strats.methods =
strats.inject =
strats.computed = function (parentVal: ?Object, childVal: ?Object): ?Object {
  ...
}
strats.provide = mergeDataOrFn

/*
  可以看到，逐步给 strats 添加合并方法（不同的属性，对应的合并策略不太一样）
  这些方法的形式都很统一：f(parentVal, childVal, vm ,key) ，最多四个参数，一般两个参数就行。
 */

// 3. 合并选项对象（简化的 mergeOptions 方法）
function mergeOptions (
  parent: Object,
  child: Object,
  vm?: Component
): Object {

  /* 打印出不合要求的组件名 */

  /* 修正 child 对象 */

  /* 
     将 child.props 的每一项都格式化成对象格式
     将数组 child.inject 转化为对象格式
     将 child.directives 的每一项都格式化成对象格式
  */

  /* 递归 mergeOptions() 修正 parent 对象 */

  const options = {}
  let key

  // ① 遍历 parent 对象的属性，合并
  for (key in parent) {
    mergeField(key)
  }

  // ② 遍历 (child - parent) 差集的属性，合并
  for (key in child) {
    if (!hasOwn(parent, key)) {
      mergeField(key)
    }
  }

  // 合并 key 选项
  function mergeField (key) {
    /*    
      其中 defaultStrat(parentVal, childVal) 是一个函数，默认合并策略函数
      也就是说，如果没有对某个 key 选项指定合并策略，就用默认的策略 defaultStrat
    */
    const strat = strats[key] || defaultStrat
    options[key] = strat(parent[key], child[key], vm, key)
  }

  return options
}

validateProp(key, propOptions, propsData, vm)
/*
  该函数执行流程为：
  ① 若属性约束条件 propOptions 规定属性 key 是布尔值，那就修正属性值为 true/false
  ② 若 propsData 中取到的 key 对应的属性值是 undefined，那就取约束条件中的默认值
  ③ 依据约束条件 propOptions 对属性是否必需，类型是否匹配，能都通过校验函数等检查
  ④ 返回属性值
 */

VNode = function VNode (
  tag,
  data,
  children,
  text,
  elm,
  context,
  componentOptions,
  asyncFactory
)

createEmptyVNode(text) // 创建文本空虚拟节点
createTextVNode(val)   // 创建文本虚拟节点
cloneVNode(vnode)      // 克隆虚拟节点
cloneVNodes(vnodes)    // 克隆一组虚拟节点

// 注意 vnode 必须是唯一的，所以克隆时必须新建一个完全独立的 vnode，而不能通过浅拷贝方式共用

// 创建组件节点，返回 vnode
createComponent (Ctor, data, context, children, tag)

// 创建与 vnode 对应的组件实例
createComponentInstanceForVnode (vnode, parent, parentElm, refElm)

createElement 函数实质是调用 _createElement 函数，返回 vnode

// 创建元素节点，返回 vnode
_createElement (context, tag, data, children, normalizationType)

// 该函数的作用是生成 vnode，分为以下几类：

// ① data && data.\_\_ob\_\_ 存在：
return createEmptyVNode()

// ② !tag 即 tag 不存在：
return createEmptyVNode()

// ③ tag 是 html/svg 内置标签名：
return vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);

// ④ tag 是组件标签名（字符串）：
return vnode = createComponent(resolveAsset(context.$options, 'components', tag), data, context, children, tag);

// ⑤ tag 是其他字符串：
return vnode = new VNode(tag, data, children, undefined, undefined, context);

// ⑥ tag 是构造函数名：
return vnode = createComponent(tag, data, context, children);

// 可以看出，除了直接调用 new VNode() 生成 vnode，还有就是用 createComponent() 和 createEmptyVNode() 来生成 vnode 

// 创建函数式组件节点，返回 vnode
createFunctionalComponent (Ctor, propsData, data, context, children)

/*
  函数式组件和普通组件定义的不同点体现在：

  1. 选项对象中显式指定 functional: true
  2. render 函数多一个参数 context 代表上下文
     其中，context 提供以下属性给组件使用：
     props：提供 props 的对象
     children: VNode 子节点的数组
     slots: slots 对象
     data：传递给组件的 data 对象
     parent：对父组件的引用
     listeners: 一个包含了组件上所注册的 v-on 侦听器的对象。这只是一个指向 data.on 的别名。
     injections: 如果使用了 inject 选项，则该对象包含了应当被注入的属性。
 */

export function createPatchFunction (backend) {

    /* 初始化 cbs = {...} */

    // 定义以下方法
    function emptyNodeAt (elm){...}
    function createRmCb (childElm, listeners){...}
    function removeNode (el){...}
    function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {...}
    function createComponent (vnode, insertedVnodeQueue, parentElm, refElm){...}
    function initComponent (vnode, insertedVnodeQueue){...}
    function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm)
    function insert (parent, elm, ref$$1){...}
    function createChildren (vnode, children, insertedVnodeQueue){...}
    function isPatchable (vnode){...}
    function invokeCreateHooks (vnode, insertedVnodeQueue){...}
    function setScope (vnode){...}
    function addVnodes(parentElm,refElm,vnodes,startIdx,endIdx,insertedVnodeQueue){...}
    function invokeDestroyHook (vnode){...}
    function removeVnodes (parentElm, vnodes, startIdx, endIdx){...}
    function removeAndInvokeRemoveHook (vnode, rm){...}
    function updateChildren(parentElm,oldCh,newCh,insertedVnodeQueue,removeOnly){...}
    function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly)
    function invokeInsertHook (vnode, queue, initial){...}
    function hydrate (elm, vnode, insertedVnodeQueue){...}
    function assertNodeMatch (node, vnode){...}

    // 最后返回 patch 函数
    return function patch (oldVnode,vnode,hydrating,removeOnly,parentElm,refElm){...}
}

// 再简化一点：
export function createPatchFunction (backend) {
    // ...
    return function patch (oldVnode,vnode,hydrating,removeOnly,parentElm,refElm){...}
}

// 实际调用时：
var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
/* 
  其中：
  ① nodeOps 对象封装了 dom 操作相关方法
  ② modules 为属性、指令等相关的生命周期方法
*/

{
  // 选项合并策略
  optionMergeStrategies: Object.create(null),

  // 是否打印警告日志
  silent: false,

  /*
     若该值为 true，那么在开发模式下会出现提示：
     当前为开发模式，若需要部署生产模式代码别忘了开启生产模式开关
   */
  productionTip: process.env.NODE_ENV !== 'production',

  // 是否开启 devtools（一种专门针对 Vue.js 的控制台调试工具）
  devtools: process.env.NODE_ENV !== 'production',

  // 是否记录耗时等性能数据
  performance: false,

  // 错误处理函数
  errorHandler: null,

  // 警告处理函数
  warnHandler: null,

  // 规定可以忽略的自定义元素。要不然 Vue 会认为是你忘记注册该组件或组件名拼错了，并抛警告。
  ignoredElements: [],

  // 给 v-on 自定义键位别名
  keyCodes: Object.create(null),

  // 检验该标签是否为保留标签（和当前平台有关）
  isReservedTag: no,

  // 检验该属性名是否为保留属性（和当前平台有关）
  isReservedAttr: no,

  // 检验该元素是否为未知元素（和当前平台有关）
  isUnknownElement: no,

  // 获取标签的命名空间，也可以理解为获取标签的文档类型（html、svg 等等）
  getTagNamespace: noop,

  // 在特点平台下解析真正的标签名
  parsePlatformTagName: identity,

  // 检查某个 attr，看其是否应该用 prop，例如 value
  mustUseProp: no,

  // 生命周期钩子函数名组成的数组
  _lifecycleHooks: LIFECYCLE_HOOKS
}

// ① 引入 Vue 构造函数，此时的 Vue 只添加了 Vue.prototype._init 等原型（实例）方法
import Vue from './instance/index'

// ② 将静态方法挂载在 Vue 上，于是就有了 Vue.extend 等全局 API
initGlobalAPI(Vue)

// ③ 定义实例属性 Vue.prototype.$isServer、Vue.prototype.$ssrContext

// ④ 定义当前 Vue 版本号（构建的时候会调用 build/config.js，将 __VERSION__ 替换为实际的版本号）
Vue.version = '__VERSION__'

// ⑤ 导出 Vue