@builder.io/sdk-vue 0.5.9 → 0.6.1-0

package/vue2/node_modules/vue/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/vue2/node_modules/vue/src/core/vdom/modules/directives.ts

@@ -0,0 +1,137 @@
+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) {
+    // @ts-expect-error emptyNode is not VNodeWithData
+    updateDirectives(vnode, emptyNode)
+  }
+}
+
+function updateDirectives(oldVnode: VNodeWithData, vnode: VNodeWithData) {
+  if (oldVnode.data.directives || vnode.data.directives) {
+    _update(oldVnode, vnode)
+  }
+}
+
+function _update(oldVnode, vnode) {
+  const isCreate = oldVnode === emptyNode
+  const isDestroy = vnode === emptyNode
+  const oldDirs = normalizeDirectives(
+    oldVnode.data.directives,
+    oldVnode.context
+  )
+  const newDirs = normalizeDirectives(vnode.data.directives, vnode.context)
+
+  const dirsWithInsert: any[] = []
+  const dirsWithPostpatch: any[] = []
+
+  let key, oldDir, dir
+  for (key in newDirs) {
+    oldDir = oldDirs[key]
+    dir = newDirs[key]
+    if (!oldDir) {
+      // new directive, bind
+      callHook(dir, 'bind', vnode, oldVnode)
+      if (dir.def && dir.def.inserted) {
+        dirsWithInsert.push(dir)
+      }
+    } else {
+      // existing directive, update
+      dir.oldValue = oldDir.value
+      dir.oldArg = oldDir.arg
+      callHook(dir, 'update', vnode, oldVnode)
+      if (dir.def && dir.def.componentUpdated) {
+        dirsWithPostpatch.push(dir)
+      }
+    }
+  }
+
+  if (dirsWithInsert.length) {
+    const callInsert = () => {
+      for (let i = 0; i < dirsWithInsert.length; i++) {
+        callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode)
+      }
+    }
+    if (isCreate) {
+      mergeVNodeHook(vnode, 'insert', callInsert)
+    } else {
+      callInsert()
+    }
+  }
+
+  if (dirsWithPostpatch.length) {
+    mergeVNodeHook(vnode, 'postpatch', () => {
+      for (let i = 0; i < dirsWithPostpatch.length; i++) {
+        callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode)
+      }
+    })
+  }
+
+  if (!isCreate) {
+    for (key in oldDirs) {
+      if (!newDirs[key]) {
+        // no longer present, unbind
+        callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy)
+      }
+    }
+  }
+}
+
+const emptyModifiers = Object.create(null)
+
+function normalizeDirectives(
+  dirs: Array<VNodeDirective> | undefined,
+  vm: Component
+): { [key: string]: VNodeDirective } {
+  const res = Object.create(null)
+  if (!dirs) {
+    // $flow-disable-line
+    return res
+  }
+  let i: number, dir: VNodeDirective
+  for (i = 0; i < dirs.length; i++) {
+    dir = dirs[i]
+    if (!dir.modifiers) {
+      // $flow-disable-line
+      dir.modifiers = emptyModifiers
+    }
+    res[getRawDirName(dir)] = dir
+    if (vm._setupState && vm._setupState.__sfc) {
+      const setupDef = dir.def || resolveAsset(vm, '_setupState', 'v-' + dir.name)
+      if (typeof setupDef === 'function') {
+        dir.def = {
+          bind: setupDef,
+          update: setupDef,
+        }
+      } else {
+        dir.def = setupDef
+      }
+    }
+    dir.def = dir.def || resolveAsset(vm.$options, 'directives', dir.name, true)
+  }
+  // $flow-disable-line
+  return res
+}
+
+function getRawDirName(dir: VNodeDirective): string {
+  return (
+    dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`
+  )
+}
+
+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: any) {
+      handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`)
+    }
+  }
+}

package/vue2/node_modules/vue/src/core/vdom/modules/index.ts

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

package/vue2/node_modules/vue/src/core/vdom/modules/template-ref.ts

@@ -0,0 +1,94 @@
+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
+  const $refsValue = isRemoval ? undefined : refValue
+
+  if (isFunction(ref)) {
+    invokeWithErrorHandling(ref, vm, [value], vm, `template ref function`)
+    return
+  }
+
+  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]
+          }
+        } else if (!existing.includes(refValue)) {
+          existing.push(refValue)
+        }
+      }
+    } else if (_isString) {
+      if (isRemoval && refs[ref] !== refValue) {
+        return
+      }
+      refs[ref] = $refsValue
+      setSetupRef(vm, ref, value)
+    } else if (_isRef) {
+      if (isRemoval && ref.value !== refValue) {
+        return
+      }
+      ref.value = 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
+    }
+  }
+}