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

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

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

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

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

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

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

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

@@ -0,0 +1,148 @@
+/**
+ * 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

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