@builder.io/sdk-vue 0.6.1-1 → 0.6.1

package/vue2/node_modules/vue/src/core/vdom/helpers/update-listeners.ts

@@ -1,101 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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
-    }
-  }
-}