vue 2.6.13 → 2.7.0-alpha.2

package/src/core/vdom/helpers/update-listeners.ts

@@ -0,0 +1,101 @@
+import { warn, invokeWithErrorHandling } from 'core/util/index'
+import { cached, isUndef, isTrue, isArray } from 'shared/util'
+import type { Component } from 'types/component'
+
+const normalizeEvent = cached(
+  (
+    name: string
+  ): {
+    name: string
+    once: boolean
+    capture: boolean
+    passive: boolean
+    handler?: Function
+    params?: Array<any>
+  } => {
+    const passive = name.charAt(0) === '&'
+    name = passive ? name.slice(1) : name
+    const once = name.charAt(0) === '~' // Prefixed last, checked first
+    name = once ? name.slice(1) : name
+    const capture = name.charAt(0) === '!'
+    name = capture ? name.slice(1) : name
+    return {
+      name,
+      once,
+      capture,
+      passive
+    }
+  }
+)
+
+export function createFnInvoker(
+  fns: Function | Array<Function>,
+  vm?: Component
+): Function {
+  function invoker() {
+    const fns = invoker.fns
+    if (isArray(fns)) {
+      const cloned = fns.slice()
+      for (let i = 0; i < cloned.length; i++) {
+        invokeWithErrorHandling(
+          cloned[i],
+          null,
+          arguments as any,
+          vm,
+          `v-on handler`
+        )
+      }
+    } else {
+      // return handler return value for single handlers
+      return invokeWithErrorHandling(
+        fns,
+        null,
+        arguments as any,
+        vm,
+        `v-on handler`
+      )
+    }
+  }
+  invoker.fns = fns
+  return invoker
+}
+
+export function updateListeners(
+  on: Object,
+  oldOn: Object,
+  add: Function,
+  remove: Function,
+  createOnceHandler: Function,
+  vm: Component
+) {
+  let name, cur, old, event
+  for (name in on) {
+    cur = on[name]
+    old = oldOn[name]
+    event = normalizeEvent(name)
+    if (isUndef(cur)) {
+      __DEV__ &&
+        warn(
+          `Invalid handler for event "${event.name}": got ` + String(cur),
+          vm
+        )
+    } else if (isUndef(old)) {
+      if (isUndef(cur.fns)) {
+        cur = on[name] = createFnInvoker(cur, vm)
+      }
+      if (isTrue(event.once)) {
+        cur = on[name] = createOnceHandler(event.name, cur, event.capture)
+      }
+      add(event.name, cur, event.capture, event.passive, event.params)
+    } else if (cur !== old) {
+      old.fns = cur
+      on[name] = old
+    }
+  }
+  for (name in oldOn) {
+    if (isUndef(on[name])) {
+      event = normalizeEvent(name)
+      remove(event.name, oldOn[name], event.capture)
+    }
+  }
+}

package/src/core/vdom/modules/{directives.js → directives.ts}

@@ -1,31 +1,35 @@
-/* @flow */
-
 import { emptyNode } from 'core/vdom/patch'
 import { resolveAsset, handleError } from 'core/util/index'
 import { mergeVNodeHook } from 'core/vdom/helpers/index'
+import type { VNodeDirective, VNodeWithData } from 'types/vnode'
+import type { Component } from 'types/component'
 
 export default {
   create: updateDirectives,
   update: updateDirectives,
-  destroy: function unbindDirectives (vnode: VNodeWithData) {
+  destroy: function unbindDirectives(vnode: VNodeWithData) {
+    // @ts-expect-error emptyNode is not VNodeWithData
     updateDirectives(vnode, emptyNode)
   }
 }
 
-function updateDirectives (oldVnode: VNodeWithData, vnode: VNodeWithData) {
+function updateDirectives(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   if (oldVnode.data.directives || vnode.data.directives) {
     _update(oldVnode, vnode)
   }
 }
 
-function _update (oldVnode, vnode) {
+function _update(oldVnode, vnode) {
   const isCreate = oldVnode === emptyNode
   const isDestroy = vnode === emptyNode
-  const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context)
+  const oldDirs = normalizeDirectives(
+    oldVnode.data.directives,
+    oldVnode.context
+  )
   const newDirs = normalizeDirectives(vnode.data.directives, vnode.context)
 
-  const dirsWithInsert = []
-  const dirsWithPostpatch = []
+  const dirsWithInsert: any[] = []
+  const dirsWithPostpatch: any[] = []
 
   let key, oldDir, dir
   for (key in newDirs) {
@@ -81,8 +85,8 @@ function _update (oldVnode, vnode) {
 
 const emptyModifiers = Object.create(null)
 
-function normalizeDirectives (
-  dirs: ?Array<VNodeDirective>,
+function normalizeDirectives(
+  dirs: Array<VNodeDirective> | undefined,
   vm: Component
 ): { [key: string]: VNodeDirective } {
   const res = Object.create(null)
@@ -104,16 +108,18 @@ function normalizeDirectives (
   return res
 }
 
-function getRawDirName (dir: VNodeDirective): string {
-  return dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`
+function getRawDirName(dir: VNodeDirective): string {
+  return (
+    dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`
+  )
 }
 
-function callHook (dir, hook, vnode, oldVnode, isDestroy) {
+function callHook(dir, hook, vnode, oldVnode, isDestroy?: any) {
   const fn = dir.def && dir.def[hook]
   if (fn) {
     try {
       fn(vnode.elm, dir, vnode, oldVnode, isDestroy)
-    } catch (e) {
+    } catch (e: any) {
       handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`)
     }
   }

package/src/core/vdom/modules/index.ts

@@ -0,0 +1,4 @@
+import directives from './directives'
+import ref from './template-ref'
+
+export default [ref, directives]

package/src/core/vdom/modules/template-ref.ts

@@ -0,0 +1,96 @@
+import {
+  remove,
+  isDef,
+  hasOwn,
+  isArray,
+  isFunction,
+  invokeWithErrorHandling,
+  warn
+} from 'core/util'
+import type { VNodeWithData } from 'types/vnode'
+import { Component } from 'types/component'
+import { isRef } from 'v3'
+
+export default {
+  create(_: any, vnode: VNodeWithData) {
+    registerRef(vnode)
+  },
+  update(oldVnode: VNodeWithData, vnode: VNodeWithData) {
+    if (oldVnode.data.ref !== vnode.data.ref) {
+      registerRef(oldVnode, true)
+      registerRef(vnode)
+    }
+  },
+  destroy(vnode: VNodeWithData) {
+    registerRef(vnode, true)
+  }
+}
+
+export function registerRef(vnode: VNodeWithData, isRemoval?: boolean) {
+  const ref = vnode.data.ref
+  if (!isDef(ref)) return
+
+  const vm = vnode.context
+  const refValue = vnode.componentInstance || vnode.elm
+  const value = isRemoval ? null : refValue
+
+  if (isFunction(ref)) {
+    invokeWithErrorHandling(ref, vm, [value], vm, `template ref function`)
+    return
+  }
+
+  const setupRefKey = vnode.data.ref_key
+  const isFor = vnode.data.refInFor
+  const _isString = typeof ref === 'string' || typeof ref === 'number'
+  const _isRef = isRef(ref)
+  const refs = vm.$refs
+
+  if (_isString || _isRef) {
+    if (isFor) {
+      const existing = _isString ? refs[ref] : ref.value
+      if (isRemoval) {
+        isArray(existing) && remove(existing, refValue)
+      } else {
+        if (!isArray(existing)) {
+          if (_isString) {
+            refs[ref] = [refValue]
+            setSetupRef(vm, ref, refs[ref])
+          } else {
+            ref.value = [refValue]
+            if (setupRefKey) refs[setupRefKey] = ref.value as any
+          }
+        } else if (!existing.includes(refValue)) {
+          existing.push(refValue)
+        }
+      }
+    } else if (_isString) {
+      if (isRemoval && refs[ref] !== refValue) {
+        return
+      }
+      refs[ref] = value
+      setSetupRef(vm, ref, value)
+    } else if (_isRef) {
+      if (isRemoval && ref.value !== refValue) {
+        return
+      }
+      ref.value = value
+      if (setupRefKey) refs[setupRefKey] = value
+    } else if (__DEV__) {
+      warn(`Invalid template ref type: ${typeof ref}`)
+    }
+  }
+}
+
+function setSetupRef(
+  { _setupState }: Component,
+  key: string | number,
+  val: any
+) {
+  if (_setupState && hasOwn(_setupState, key as string)) {
+    if (isRef(_setupState[key])) {
+      _setupState[key].value = val
+    } else {
+      _setupState[key] = val
+    }
+  }
+}