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

package/vue2/node_modules/vue/src/platforms/web/runtime/class-util.ts

@@ -1,61 +0,0 @@
-const whitespaceRE = /\s+/
-
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-export function addClass(el: HTMLElement, cls?: string) {
-  /* istanbul ignore if */
-  if (!cls || !(cls = cls.trim())) {
-    return
-  }
-
-  /* istanbul ignore else */
-  if (el.classList) {
-    if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(c => el.classList.add(c))
-    } else {
-      el.classList.add(cls)
-    }
-  } else {
-    const cur = ` ${el.getAttribute('class') || ''} `
-    if (cur.indexOf(' ' + cls + ' ') < 0) {
-      el.setAttribute('class', (cur + cls).trim())
-    }
-  }
-}
-
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-export function removeClass(el: HTMLElement, cls?: string) {
-  /* istanbul ignore if */
-  if (!cls || !(cls = cls.trim())) {
-    return
-  }
-
-  /* istanbul ignore else */
-  if (el.classList) {
-    if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(c => el.classList.remove(c))
-    } else {
-      el.classList.remove(cls)
-    }
-    if (!el.classList.length) {
-      el.removeAttribute('class')
-    }
-  } else {
-    let cur = ` ${el.getAttribute('class') || ''} `
-    const tar = ' ' + cls + ' '
-    while (cur.indexOf(tar) >= 0) {
-      cur = cur.replace(tar, ' ')
-    }
-    cur = cur.trim()
-    if (cur) {
-      el.setAttribute('class', cur)
-    } else {
-      el.removeAttribute('class')
-    }
-  }
-}

package/vue2/node_modules/vue/src/platforms/web/runtime/components/index.ts

@@ -1,7 +0,0 @@
-import Transition from './transition'
-import TransitionGroup from './transition-group'
-
-export default {
-  Transition,
-  TransitionGroup
-}

package/vue2/node_modules/vue/src/platforms/web/runtime/components/transition-group.ts

@@ -1,204 +0,0 @@
-// Provides transition support for list items.
-// supports move transitions using the FLIP technique.
-
-// Because the vdom's children update algorithm is "unstable" - i.e.
-// it doesn't guarantee the relative positioning of removed elements,
-// we force transition-group to update its children into two passes:
-// in the first pass, we remove all nodes that need to be removed,
-// triggering their leaving transition; in the second pass, we insert/move
-// into the final desired state. This way in the second pass removed
-// nodes will remain where they should be.
-
-import { warn, extend } from 'core/util/index'
-import { addClass, removeClass } from 'web/runtime/class-util'
-import { transitionProps, extractTransitionData } from './transition'
-import { setActiveInstance } from 'core/instance/lifecycle'
-
-import {
-  hasTransition,
-  getTransitionInfo,
-  transitionEndEvent,
-  addTransitionClass,
-  removeTransitionClass
-} from 'web/runtime/transition-util'
-import VNode from 'core/vdom/vnode'
-import { VNodeWithData } from 'types/vnode'
-import { getComponentName } from 'core/vdom/create-component'
-
-const props = extend(
-  {
-    tag: String,
-    moveClass: String
-  },
-  transitionProps
-)
-
-delete props.mode
-
-export default {
-  props,
-
-  beforeMount() {
-    const update = this._update
-    this._update = (vnode, hydrating) => {
-      const restoreActiveInstance = setActiveInstance(this)
-      // force removing pass
-      this.__patch__(
-        this._vnode,
-        this.kept,
-        false, // hydrating
-        true // removeOnly (!important, avoids unnecessary moves)
-      )
-      this._vnode = this.kept
-      restoreActiveInstance()
-      update.call(this, vnode, hydrating)
-    }
-  },
-
-  render(h: Function) {
-    const tag: string = this.tag || this.$vnode.data.tag || 'span'
-    const map: Record<string, any> = Object.create(null)
-    const prevChildren: Array<VNode> = (this.prevChildren = this.children)
-    const rawChildren: Array<VNode> = this.$slots.default || []
-    const children: Array<VNode> = (this.children = [])
-    const transitionData = extractTransitionData(this)
-
-    for (let i = 0; i < rawChildren.length; i++) {
-      const c: VNode = rawChildren[i]
-      if (c.tag) {
-        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-          children.push(c)
-          map[c.key] = c
-          ;(c.data || (c.data = {})).transition = transitionData
-        } else if (__DEV__) {
-          const opts = c.componentOptions
-          const name: string = opts
-            ? getComponentName(opts.Ctor.options as any) || opts.tag || ''
-            : c.tag
-          warn(`<transition-group> children must be keyed: <${name}>`)
-        }
-      }
-    }
-
-    if (prevChildren) {
-      const kept: Array<VNode> = []
-      const removed: Array<VNode> = []
-      for (let i = 0; i < prevChildren.length; i++) {
-        const c: VNode = prevChildren[i]
-        c.data!.transition = transitionData
-        // @ts-expect-error .getBoundingClientRect is not typed in Node
-        c.data!.pos = c.elm.getBoundingClientRect()
-        if (map[c.key!]) {
-          kept.push(c)
-        } else {
-          removed.push(c)
-        }
-      }
-      this.kept = h(tag, null, kept)
-      this.removed = removed
-    }
-
-    return h(tag, null, children)
-  },
-
-  updated() {
-    const children: Array<VNodeWithData> = this.prevChildren
-    const moveClass: string = this.moveClass || (this.name || 'v') + '-move'
-    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-      return
-    }
-
-    // we divide the work into three loops to avoid mixing DOM reads and writes
-    // in each iteration - which helps prevent layout thrashing.
-    children.forEach(callPendingCbs)
-    children.forEach(recordPosition)
-    children.forEach(applyTranslation)
-
-    // force reflow to put everything in position
-    // assign to this to avoid being removed in tree-shaking
-    // $flow-disable-line
-    this._reflow = document.body.offsetHeight
-
-    children.forEach((c: VNode) => {
-      if (c.data!.moved) {
-        const el: any = c.elm
-        const s: any = el.style
-        addTransitionClass(el, moveClass)
-        s.transform = s.WebkitTransform = s.transitionDuration = ''
-        el.addEventListener(
-          transitionEndEvent,
-          (el._moveCb = function cb(e) {
-            if (e && e.target !== el) {
-              return
-            }
-            if (!e || /transform$/.test(e.propertyName)) {
-              el.removeEventListener(transitionEndEvent, cb)
-              el._moveCb = null
-              removeTransitionClass(el, moveClass)
-            }
-          })
-        )
-      }
-    })
-  },
-
-  methods: {
-    hasMove(el: any, moveClass: string): boolean {
-      /* istanbul ignore if */
-      if (!hasTransition) {
-        return false
-      }
-      /* istanbul ignore if */
-      if (this._hasMove) {
-        return this._hasMove
-      }
-      // Detect whether an element with the move class applied has
-      // CSS transitions. Since the element may be inside an entering
-      // transition at this very moment, we make a clone of it and remove
-      // all other transition classes applied to ensure only the move class
-      // is applied.
-      const clone: HTMLElement = el.cloneNode()
-      if (el._transitionClasses) {
-        el._transitionClasses.forEach((cls: string) => {
-          removeClass(clone, cls)
-        })
-      }
-      addClass(clone, moveClass)
-      clone.style.display = 'none'
-      this.$el.appendChild(clone)
-      const info: any = getTransitionInfo(clone)
-      this.$el.removeChild(clone)
-      return (this._hasMove = info.hasTransform)
-    }
-  }
-}
-
-function callPendingCbs(
-  c: VNodeWithData & { elm?: { _moveCb?: Function; _enterCb?: Function } }
-) {
-  /* istanbul ignore if */
-  if (c.elm!._moveCb) {
-    c.elm!._moveCb()
-  }
-  /* istanbul ignore if */
-  if (c.elm!._enterCb) {
-    c.elm!._enterCb()
-  }
-}
-
-function recordPosition(c: VNodeWithData) {
-  c.data!.newPos = c.elm.getBoundingClientRect()
-}
-
-function applyTranslation(c: VNodeWithData) {
-  const oldPos = c.data.pos
-  const newPos = c.data.newPos
-  const dx = oldPos.left - newPos.left
-  const dy = oldPos.top - newPos.top
-  if (dx || dy) {
-    c.data.moved = true
-    const s = c.elm.style
-    s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`
-    s.transitionDuration = '0s'
-  }
-}

package/vue2/node_modules/vue/src/platforms/web/runtime/components/transition.ts

@@ -1,205 +0,0 @@
-// Provides transition support for a single element/component.
-// supports transition mode (out-in / in-out)
-
-import { warn } from 'core/util/index'
-import { camelize, extend, isPrimitive } from 'shared/util'
-import {
-  mergeVNodeHook,
-  isAsyncPlaceholder,
-  getFirstComponentChild
-} from 'core/vdom/helpers/index'
-import VNode from 'core/vdom/vnode'
-import type { Component } from 'types/component'
-
-export const transitionProps = {
-  name: String,
-  appear: Boolean,
-  css: Boolean,
-  mode: String,
-  type: String,
-  enterClass: String,
-  leaveClass: String,
-  enterToClass: String,
-  leaveToClass: String,
-  enterActiveClass: String,
-  leaveActiveClass: String,
-  appearClass: String,
-  appearActiveClass: String,
-  appearToClass: String,
-  duration: [Number, String, Object]
-}
-
-// in case the child is also an abstract component, e.g. <keep-alive>
-// we want to recursively retrieve the real component to be rendered
-function getRealChild(vnode?: VNode): VNode | undefined {
-  const compOptions = vnode && vnode.componentOptions
-  if (compOptions && compOptions.Ctor.options.abstract) {
-    return getRealChild(getFirstComponentChild(compOptions.children))
-  } else {
-    return vnode
-  }
-}
-
-export function extractTransitionData(comp: Component): Record<string, any> {
-  const data = {}
-  const options = comp.$options
-  // props
-  for (const key in options.propsData) {
-    data[key] = comp[key]
-  }
-  // events.
-  // extract listeners and pass them directly to the transition methods
-  const listeners = options._parentListeners
-  for (const key in listeners) {
-    data[camelize(key)] = listeners[key]
-  }
-  return data
-}
-
-function placeholder(h: Function, rawChild: VNode): VNode | undefined {
-  // @ts-expect-error
-  if (/\d-keep-alive$/.test(rawChild.tag)) {
-    return h('keep-alive', {
-      props: rawChild.componentOptions!.propsData
-    })
-  }
-}
-
-function hasParentTransition(vnode: VNode): boolean | undefined {
-  while ((vnode = vnode.parent!)) {
-    if (vnode.data!.transition) {
-      return true
-    }
-  }
-}
-
-function isSameChild(child: VNode, oldChild: VNode): boolean {
-  return oldChild.key === child.key && oldChild.tag === child.tag
-}
-
-const isNotTextNode = (c: VNode) => c.tag || isAsyncPlaceholder(c)
-
-const isVShowDirective = d => d.name === 'show'
-
-export default {
-  name: 'transition',
-  props: transitionProps,
-  abstract: true,
-
-  render(h: Function) {
-    let children: any = this.$slots.default
-    if (!children) {
-      return
-    }
-
-    // filter out text nodes (possible whitespaces)
-    children = children.filter(isNotTextNode)
-    /* istanbul ignore if */
-    if (!children.length) {
-      return
-    }
-
-    // warn multiple elements
-    if (__DEV__ && children.length > 1) {
-      warn(
-        '<transition> can only be used on a single element. Use ' +
-          '<transition-group> for lists.',
-        this.$parent
-      )
-    }
-
-    const mode: string = this.mode
-
-    // warn invalid mode
-    if (__DEV__ && mode && mode !== 'in-out' && mode !== 'out-in') {
-      warn('invalid <transition> mode: ' + mode, this.$parent)
-    }
-
-    const rawChild: VNode = children[0]
-
-    // if this is a component root node and the component's
-    // parent container node also has transition, skip.
-    if (hasParentTransition(this.$vnode)) {
-      return rawChild
-    }
-
-    // apply transition data to child
-    // use getRealChild() to ignore abstract components e.g. keep-alive
-    const child = getRealChild(rawChild)
-    /* istanbul ignore if */
-    if (!child) {
-      return rawChild
-    }
-
-    if (this._leaving) {
-      return placeholder(h, rawChild)
-    }
-
-    // ensure a key that is unique to the vnode type and to this transition
-    // component instance. This key will be used to remove pending leaving nodes
-    // during entering.
-    const id: string = `__transition-${this._uid}-`
-    child.key =
-      child.key == null
-        ? child.isComment
-          ? id + 'comment'
-          : id + child.tag
-        : isPrimitive(child.key)
-        ? String(child.key).indexOf(id) === 0
-          ? child.key
-          : id + child.key
-        : child.key
-
-    const data: Object = ((child.data || (child.data = {})).transition =
-      extractTransitionData(this))
-    const oldRawChild: VNode = this._vnode
-    const oldChild = getRealChild(oldRawChild)
-
-    // mark v-show
-    // so that the transition module can hand over the control to the directive
-    if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-      child.data.show = true
-    }
-
-    if (
-      oldChild &&
-      oldChild.data &&
-      !isSameChild(child, oldChild) &&
-      !isAsyncPlaceholder(oldChild) &&
-      // #6687 component root is a comment node
-      !(
-        oldChild.componentInstance &&
-        oldChild.componentInstance._vnode!.isComment
-      )
-    ) {
-      // replace old child transition data with fresh one
-      // important for dynamic transitions!
-      const oldData: Object = (oldChild.data.transition = extend({}, data))
-      // handle transition mode
-      if (mode === 'out-in') {
-        // return placeholder node and queue update when leave finishes
-        this._leaving = true
-        mergeVNodeHook(oldData, 'afterLeave', () => {
-          this._leaving = false
-          this.$forceUpdate()
-        })
-        return placeholder(h, rawChild)
-      } else if (mode === 'in-out') {
-        if (isAsyncPlaceholder(child)) {
-          return oldRawChild
-        }
-        let delayedLeave
-        const performLeave = () => {
-          delayedLeave()
-        }
-        mergeVNodeHook(data, 'afterEnter', performLeave)
-        mergeVNodeHook(data, 'enterCancelled', performLeave)
-        mergeVNodeHook(oldData, 'delayLeave', leave => {
-          delayedLeave = leave
-        })
-      }
-    }
-
-    return rawChild
-  }
-}

package/vue2/node_modules/vue/src/platforms/web/runtime/directives/index.ts

@@ -1,7 +0,0 @@
-import model from './model'
-import show from './show'
-
-export default {
-  model,
-  show
-}

package/vue2/node_modules/vue/src/platforms/web/runtime/directives/model.ts

@@ -1,148 +0,0 @@
-/**
- * Not type checking this file because flow doesn't like attaching
- * properties to Elements.
- */
-
-import { isTextInputType } from 'web/util/element'
-import { looseEqual, looseIndexOf } from 'shared/util'
-import { mergeVNodeHook } from 'core/vdom/helpers/index'
-import { warn, isIE9, isIE, isEdge } from 'core/util/index'
-
-/* istanbul ignore if */
-if (isIE9) {
-  // http://www.matts411.com/post/internet-explorer-9-oninput/
-  document.addEventListener('selectionchange', () => {
-    const el = document.activeElement
-    // @ts-expect-error
-    if (el && el.vmodel) {
-      trigger(el, 'input')
-    }
-  })
-}
-
-const directive = {
-  inserted(el, binding, vnode, oldVnode) {
-    if (vnode.tag === 'select') {
-      // #6903
-      if (oldVnode.elm && !oldVnode.elm._vOptions) {
-        mergeVNodeHook(vnode, 'postpatch', () => {
-          directive.componentUpdated(el, binding, vnode)
-        })
-      } else {
-        setSelected(el, binding, vnode.context)
-      }
-      el._vOptions = [].map.call(el.options, getValue)
-    } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-      el._vModifiers = binding.modifiers
-      if (!binding.modifiers.lazy) {
-        el.addEventListener('compositionstart', onCompositionStart)
-        el.addEventListener('compositionend', onCompositionEnd)
-        // Safari < 10.2 & UIWebView doesn't fire compositionend when
-        // switching focus before confirming composition choice
-        // this also fixes the issue where some browsers e.g. iOS Chrome
-        // fires "change" instead of "input" on autocomplete.
-        el.addEventListener('change', onCompositionEnd)
-        /* istanbul ignore if */
-        if (isIE9) {
-          el.vmodel = true
-        }
-      }
-    }
-  },
-
-  componentUpdated(el, binding, vnode) {
-    if (vnode.tag === 'select') {
-      setSelected(el, binding, vnode.context)
-      // in case the options rendered by v-for have changed,
-      // it's possible that the value is out-of-sync with the rendered options.
-      // detect such cases and filter out values that no longer has a matching
-      // option in the DOM.
-      const prevOptions = el._vOptions
-      const curOptions = (el._vOptions = [].map.call(el.options, getValue))
-      if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-        // trigger change event if
-        // no matching option found for at least one value
-        const needReset = el.multiple
-          ? binding.value.some(v => hasNoMatchingOption(v, curOptions))
-          : binding.value !== binding.oldValue &&
-            hasNoMatchingOption(binding.value, curOptions)
-        if (needReset) {
-          trigger(el, 'change')
-        }
-      }
-    }
-  }
-}
-
-function setSelected(el, binding, vm) {
-  actuallySetSelected(el, binding, vm)
-  /* istanbul ignore if */
-  if (isIE || isEdge) {
-    setTimeout(() => {
-      actuallySetSelected(el, binding, vm)
-    }, 0)
-  }
-}
-
-function actuallySetSelected(el, binding, vm) {
-  const value = binding.value
-  const isMultiple = el.multiple
-  if (isMultiple && !Array.isArray(value)) {
-    __DEV__ &&
-      warn(
-        `<select multiple v-model="${binding.expression}"> ` +
-          `expects an Array value for its binding, but got ${Object.prototype.toString
-            .call(value)
-            .slice(8, -1)}`,
-        vm
-      )
-    return
-  }
-  let selected, option
-  for (let i = 0, l = el.options.length; i < l; i++) {
-    option = el.options[i]
-    if (isMultiple) {
-      selected = looseIndexOf(value, getValue(option)) > -1
-      if (option.selected !== selected) {
-        option.selected = selected
-      }
-    } else {
-      if (looseEqual(getValue(option), value)) {
-        if (el.selectedIndex !== i) {
-          el.selectedIndex = i
-        }
-        return
-      }
-    }
-  }
-  if (!isMultiple) {
-    el.selectedIndex = -1
-  }
-}
-
-function hasNoMatchingOption(value, options) {
-  return options.every(o => !looseEqual(o, value))
-}
-
-function getValue(option) {
-  return '_value' in option ? option._value : option.value
-}
-
-function onCompositionStart(e) {
-  e.target.composing = true
-}
-
-function onCompositionEnd(e) {
-  // prevent triggering an input event for no reason
-  if (!e.target.composing) return
-  e.target.composing = false
-  trigger(e.target, 'input')
-}
-
-function trigger(el, type) {
-  const e = document.createEvent('HTMLEvents')
-  e.initEvent(type, true, true)
-  el.dispatchEvent(e)
-}
-
-export default directive

package/vue2/node_modules/vue/src/platforms/web/runtime/directives/show.ts

@@ -1,61 +0,0 @@
-import VNode from 'core/vdom/vnode'
-import type { VNodeDirective, VNodeWithData } from 'types/vnode'
-import { enter, leave } from 'web/runtime/modules/transition'
-
-// recursively search for possible transition defined inside the component root
-function locateNode(vnode: VNode | VNodeWithData): VNodeWithData {
-  // @ts-expect-error
-  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-    ? locateNode(vnode.componentInstance._vnode!)
-    : vnode
-}
-
-export default {
-  bind(el: any, { value }: VNodeDirective, vnode: VNodeWithData) {
-    vnode = locateNode(vnode)
-    const transition = vnode.data && vnode.data.transition
-    const originalDisplay = (el.__vOriginalDisplay =
-      el.style.display === 'none' ? '' : el.style.display)
-    if (value && transition) {
-      vnode.data.show = true
-      enter(vnode, () => {
-        el.style.display = originalDisplay
-      })
-    } else {
-      el.style.display = value ? originalDisplay : 'none'
-    }
-  },
-
-  update(el: any, { value, oldValue }: VNodeDirective, vnode: VNodeWithData) {
-    /* istanbul ignore if */
-    if (!value === !oldValue) return
-    vnode = locateNode(vnode)
-    const transition = vnode.data && vnode.data.transition
-    if (transition) {
-      vnode.data.show = true
-      if (value) {
-        enter(vnode, () => {
-          el.style.display = el.__vOriginalDisplay
-        })
-      } else {
-        leave(vnode, () => {
-          el.style.display = 'none'
-        })
-      }
-    } else {
-      el.style.display = value ? el.__vOriginalDisplay : 'none'
-    }
-  },
-
-  unbind(
-    el: any,
-    binding: VNodeDirective,
-    vnode: VNodeWithData,
-    oldVnode: VNodeWithData,
-    isDestroy: boolean
-  ) {
-    if (!isDestroy) {
-      el.style.display = el.__vOriginalDisplay
-    }
-  }
-}