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

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

@@ -1,341 +0,0 @@
-import { inBrowser, isIE9, warn } from 'core/util/index'
-import { mergeVNodeHook } from 'core/vdom/helpers/index'
-import { activeInstance } from 'core/instance/lifecycle'
-
-import {
-  once,
-  isDef,
-  isUndef,
-  isObject,
-  toNumber,
-  isFunction
-} from 'shared/util'
-
-import {
-  nextFrame,
-  resolveTransition,
-  whenTransitionEnds,
-  addTransitionClass,
-  removeTransitionClass
-} from 'web/runtime/transition-util'
-
-import type { VNodeWithData } from 'types/vnode'
-import VNode from 'core/vdom/vnode'
-
-export function enter(vnode: VNodeWithData, toggleDisplay?: () => void) {
-  const el: any = vnode.elm
-
-  // call leave callback now
-  if (isDef(el._leaveCb)) {
-    el._leaveCb.cancelled = true
-    el._leaveCb()
-  }
-
-  const data = resolveTransition(vnode.data.transition)
-  if (isUndef(data)) {
-    return
-  }
-
-  /* istanbul ignore if */
-  if (isDef(el._enterCb) || el.nodeType !== 1) {
-    return
-  }
-
-  const {
-    css,
-    type,
-    enterClass,
-    enterToClass,
-    enterActiveClass,
-    appearClass,
-    appearToClass,
-    appearActiveClass,
-    beforeEnter,
-    enter,
-    afterEnter,
-    enterCancelled,
-    beforeAppear,
-    appear,
-    afterAppear,
-    appearCancelled,
-    duration
-  } = data
-
-  // activeInstance will always be the <transition> component managing this
-  // transition. One edge case to check is when the <transition> is placed
-  // as the root node of a child component. In that case we need to check
-  // <transition>'s parent for appear check.
-  let context = activeInstance
-  let transitionNode = activeInstance.$vnode
-  while (transitionNode && transitionNode.parent) {
-    context = transitionNode.context
-    transitionNode = transitionNode.parent
-  }
-
-  const isAppear = !context._isMounted || !vnode.isRootInsert
-
-  if (isAppear && !appear && appear !== '') {
-    return
-  }
-
-  const startClass = isAppear && appearClass ? appearClass : enterClass
-  const activeClass =
-    isAppear && appearActiveClass ? appearActiveClass : enterActiveClass
-  const toClass = isAppear && appearToClass ? appearToClass : enterToClass
-
-  const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter
-  const enterHook = isAppear ? (isFunction(appear) ? appear : enter) : enter
-  const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter
-  const enterCancelledHook = isAppear
-    ? appearCancelled || enterCancelled
-    : enterCancelled
-
-  const explicitEnterDuration: any = toNumber(
-    isObject(duration) ? duration.enter : duration
-  )
-
-  if (__DEV__ && explicitEnterDuration != null) {
-    checkDuration(explicitEnterDuration, 'enter', vnode)
-  }
-
-  const expectsCSS = css !== false && !isIE9
-  const userWantsControl = getHookArgumentsLength(enterHook)
-
-  const cb = (el._enterCb = once(() => {
-    if (expectsCSS) {
-      removeTransitionClass(el, toClass)
-      removeTransitionClass(el, activeClass)
-    }
-    // @ts-expect-error
-    if (cb.cancelled) {
-      if (expectsCSS) {
-        removeTransitionClass(el, startClass)
-      }
-      enterCancelledHook && enterCancelledHook(el)
-    } else {
-      afterEnterHook && afterEnterHook(el)
-    }
-    el._enterCb = null
-  }))
-
-  if (!vnode.data.show) {
-    // remove pending leave element on enter by injecting an insert hook
-    mergeVNodeHook(vnode, 'insert', () => {
-      const parent = el.parentNode
-      const pendingNode =
-        parent && parent._pending && parent._pending[vnode.key!]
-      if (
-        pendingNode &&
-        pendingNode.tag === vnode.tag &&
-        pendingNode.elm._leaveCb
-      ) {
-        pendingNode.elm._leaveCb()
-      }
-      enterHook && enterHook(el, cb)
-    })
-  }
-
-  // start enter transition
-  beforeEnterHook && beforeEnterHook(el)
-  if (expectsCSS) {
-    addTransitionClass(el, startClass)
-    addTransitionClass(el, activeClass)
-    nextFrame(() => {
-      removeTransitionClass(el, startClass)
-      // @ts-expect-error
-      if (!cb.cancelled) {
-        addTransitionClass(el, toClass)
-        if (!userWantsControl) {
-          if (isValidDuration(explicitEnterDuration)) {
-            setTimeout(cb, explicitEnterDuration)
-          } else {
-            whenTransitionEnds(el, type, cb)
-          }
-        }
-      }
-    })
-  }
-
-  if (vnode.data.show) {
-    toggleDisplay && toggleDisplay()
-    enterHook && enterHook(el, cb)
-  }
-
-  if (!expectsCSS && !userWantsControl) {
-    cb()
-  }
-}
-
-export function leave(vnode: VNodeWithData, rm: Function) {
-  const el: any = vnode.elm
-
-  // call enter callback now
-  if (isDef(el._enterCb)) {
-    el._enterCb.cancelled = true
-    el._enterCb()
-  }
-
-  const data = resolveTransition(vnode.data.transition)
-  if (isUndef(data) || el.nodeType !== 1) {
-    return rm()
-  }
-
-  /* istanbul ignore if */
-  if (isDef(el._leaveCb)) {
-    return
-  }
-
-  const {
-    css,
-    type,
-    leaveClass,
-    leaveToClass,
-    leaveActiveClass,
-    beforeLeave,
-    leave,
-    afterLeave,
-    leaveCancelled,
-    delayLeave,
-    duration
-  } = data
-
-  const expectsCSS = css !== false && !isIE9
-  const userWantsControl = getHookArgumentsLength(leave)
-
-  const explicitLeaveDuration: any = toNumber(
-    isObject(duration) ? duration.leave : duration
-  )
-
-  if (__DEV__ && isDef(explicitLeaveDuration)) {
-    checkDuration(explicitLeaveDuration, 'leave', vnode)
-  }
-
-  const cb = (el._leaveCb = once(() => {
-    if (el.parentNode && el.parentNode._pending) {
-      el.parentNode._pending[vnode.key!] = null
-    }
-    if (expectsCSS) {
-      removeTransitionClass(el, leaveToClass)
-      removeTransitionClass(el, leaveActiveClass)
-    }
-    // @ts-expect-error
-    if (cb.cancelled) {
-      if (expectsCSS) {
-        removeTransitionClass(el, leaveClass)
-      }
-      leaveCancelled && leaveCancelled(el)
-    } else {
-      rm()
-      afterLeave && afterLeave(el)
-    }
-    el._leaveCb = null
-  }))
-
-  if (delayLeave) {
-    delayLeave(performLeave)
-  } else {
-    performLeave()
-  }
-
-  function performLeave() {
-    // the delayed leave may have already been cancelled
-    // @ts-expect-error
-    if (cb.cancelled) {
-      return
-    }
-    // record leaving element
-    if (!vnode.data.show && el.parentNode) {
-      ;(el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key!] =
-        vnode
-    }
-    beforeLeave && beforeLeave(el)
-    if (expectsCSS) {
-      addTransitionClass(el, leaveClass)
-      addTransitionClass(el, leaveActiveClass)
-      nextFrame(() => {
-        removeTransitionClass(el, leaveClass)
-        // @ts-expect-error
-        if (!cb.cancelled) {
-          addTransitionClass(el, leaveToClass)
-          if (!userWantsControl) {
-            if (isValidDuration(explicitLeaveDuration)) {
-              setTimeout(cb, explicitLeaveDuration)
-            } else {
-              whenTransitionEnds(el, type, cb)
-            }
-          }
-        }
-      })
-    }
-    leave && leave(el, cb)
-    if (!expectsCSS && !userWantsControl) {
-      cb()
-    }
-  }
-}
-
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-  if (typeof val !== 'number') {
-    warn(
-      `<transition> explicit ${name} duration is not a valid number - ` +
-        `got ${JSON.stringify(val)}.`,
-      vnode.context
-    )
-  } else if (isNaN(val)) {
-    warn(
-      `<transition> explicit ${name} duration is NaN - ` +
-        'the duration expression might be incorrect.',
-      vnode.context
-    )
-  }
-}
-
-function isValidDuration(val) {
-  return typeof val === 'number' && !isNaN(val)
-}
-
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn: Function): boolean {
-  if (isUndef(fn)) {
-    return false
-  }
-  // @ts-expect-error
-  const invokerFns = fn.fns
-  if (isDef(invokerFns)) {
-    // invoker
-    return getHookArgumentsLength(
-      Array.isArray(invokerFns) ? invokerFns[0] : invokerFns
-    )
-  } else {
-    // @ts-expect-error
-    return (fn._length || fn.length) > 1
-  }
-}
-
-function _enter(_: any, vnode: VNodeWithData) {
-  if (vnode.data.show !== true) {
-    enter(vnode)
-  }
-}
-
-export default inBrowser
-  ? {
-      create: _enter,
-      activate: _enter,
-      remove(vnode: VNode, rm: Function) {
-        /* istanbul ignore else */
-        if (vnode.data!.show !== true) {
-          // @ts-expect-error
-          leave(vnode, rm)
-        } else {
-          rm()
-        }
-      }
-    }
-  : {}

package/vue2/node_modules/vue/src/platforms/web/runtime/node-ops.ts

@@ -1,66 +0,0 @@
-import VNode from 'core/vdom/vnode'
-import { namespaceMap } from 'web/util/index'
-
-export function createElement(tagName: string, vnode: VNode): Element {
-  const elm = document.createElement(tagName)
-  if (tagName !== 'select') {
-    return elm
-  }
-  // false or null will remove the attribute but undefined will not
-  if (
-    vnode.data &&
-    vnode.data.attrs &&
-    vnode.data.attrs.multiple !== undefined
-  ) {
-    elm.setAttribute('multiple', 'multiple')
-  }
-  return elm
-}
-
-export function createElementNS(namespace: string, tagName: string): Element {
-  return document.createElementNS(namespaceMap[namespace], tagName)
-}
-
-export function createTextNode(text: string): Text {
-  return document.createTextNode(text)
-}
-
-export function createComment(text: string): Comment {
-  return document.createComment(text)
-}
-
-export function insertBefore(
-  parentNode: Node,
-  newNode: Node,
-  referenceNode: Node
-) {
-  parentNode.insertBefore(newNode, referenceNode)
-}
-
-export function removeChild(node: Node, child: Node) {
-  node.removeChild(child)
-}
-
-export function appendChild(node: Node, child: Node) {
-  node.appendChild(child)
-}
-
-export function parentNode(node: Node) {
-  return node.parentNode
-}
-
-export function nextSibling(node: Node) {
-  return node.nextSibling
-}
-
-export function tagName(node: Element): string {
-  return node.tagName
-}
-
-export function setTextContent(node: Node, text: string) {
-  node.textContent = text
-}
-
-export function setStyleScope(node: Element, scopeId: string) {
-  node.setAttribute(scopeId, '')
-}

package/vue2/node_modules/vue/src/platforms/web/runtime/patch.ts

@@ -1,10 +0,0 @@
-import * as nodeOps from 'web/runtime/node-ops'
-import { createPatchFunction } from 'core/vdom/patch'
-import baseModules from 'core/vdom/modules/index'
-import platformModules from 'web/runtime/modules/index'
-
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-const modules = platformModules.concat(baseModules)
-
-export const patch: Function = createPatchFunction({ nodeOps, modules })

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

@@ -1,215 +0,0 @@
-import { inBrowser, isIE9 } from 'core/util/index'
-import { addClass, removeClass } from 'web/runtime/class-util'
-import { remove, extend, cached } from 'shared/util'
-
-export function resolveTransition(
-  def?: string | Record<string, any>
-): Record<string, any> | undefined {
-  if (!def) {
-    return
-  }
-  /* istanbul ignore else */
-  if (typeof def === 'object') {
-    const res = {}
-    if (def.css !== false) {
-      extend(res, autoCssTransition(def.name || 'v'))
-    }
-    extend(res, def)
-    return res
-  } else if (typeof def === 'string') {
-    return autoCssTransition(def)
-  }
-}
-
-const autoCssTransition: (name: string) => Object = cached(name => {
-  return {
-    enterClass: `${name}-enter`,
-    enterToClass: `${name}-enter-to`,
-    enterActiveClass: `${name}-enter-active`,
-    leaveClass: `${name}-leave`,
-    leaveToClass: `${name}-leave-to`,
-    leaveActiveClass: `${name}-leave-active`
-  }
-})
-
-export const hasTransition = inBrowser && !isIE9
-const TRANSITION = 'transition'
-const ANIMATION = 'animation'
-
-// Transition property/event sniffing
-export let transitionProp = 'transition'
-export let transitionEndEvent = 'transitionend'
-export let animationProp = 'animation'
-export let animationEndEvent = 'animationend'
-if (hasTransition) {
-  /* istanbul ignore if */
-  if (
-    window.ontransitionend === undefined &&
-    window.onwebkittransitionend !== undefined
-  ) {
-    transitionProp = 'WebkitTransition'
-    transitionEndEvent = 'webkitTransitionEnd'
-  }
-  if (
-    window.onanimationend === undefined &&
-    window.onwebkitanimationend !== undefined
-  ) {
-    animationProp = 'WebkitAnimation'
-    animationEndEvent = 'webkitAnimationEnd'
-  }
-}
-
-// binding to window is necessary to make hot reload work in IE in strict mode
-const raf = inBrowser
-  ? window.requestAnimationFrame
-    ? window.requestAnimationFrame.bind(window)
-    : setTimeout
-  : /* istanbul ignore next */ fn => fn()
-
-export function nextFrame(fn: Function) {
-  raf(() => {
-    // @ts-expect-error
-    raf(fn)
-  })
-}
-
-export function addTransitionClass(el: any, cls: string) {
-  const transitionClasses =
-    el._transitionClasses || (el._transitionClasses = [])
-  if (transitionClasses.indexOf(cls) < 0) {
-    transitionClasses.push(cls)
-    addClass(el, cls)
-  }
-}
-
-export function removeTransitionClass(el: any, cls: string) {
-  if (el._transitionClasses) {
-    remove(el._transitionClasses, cls)
-  }
-  removeClass(el, cls)
-}
-
-export function whenTransitionEnds(
-  el: Element,
-  expectedType: string | undefined,
-  cb: Function
-) {
-  const { type, timeout, propCount } = getTransitionInfo(el, expectedType)
-  if (!type) return cb()
-  const event: string =
-    type === TRANSITION ? transitionEndEvent : animationEndEvent
-  let ended = 0
-  const end = () => {
-    el.removeEventListener(event, onEnd)
-    cb()
-  }
-  const onEnd = e => {
-    if (e.target === el) {
-      if (++ended >= propCount) {
-        end()
-      }
-    }
-  }
-  setTimeout(() => {
-    if (ended < propCount) {
-      end()
-    }
-  }, timeout + 1)
-  el.addEventListener(event, onEnd)
-}
-
-const transformRE = /\b(transform|all)(,|$)/
-
-export function getTransitionInfo(
-  el: Element,
-  expectedType?: string
-): {
-  type?: string | null
-  propCount: number
-  timeout: number
-  hasTransform: boolean
-} {
-  const styles: any = window.getComputedStyle(el)
-  // JSDOM may return undefined for transition properties
-  const transitionDelays: Array<string> = (
-    styles[transitionProp + 'Delay'] || ''
-  ).split(', ')
-  const transitionDurations: Array<string> = (
-    styles[transitionProp + 'Duration'] || ''
-  ).split(', ')
-  const transitionTimeout: number = getTimeout(
-    transitionDelays,
-    transitionDurations
-  )
-  const animationDelays: Array<string> = (
-    styles[animationProp + 'Delay'] || ''
-  ).split(', ')
-  const animationDurations: Array<string> = (
-    styles[animationProp + 'Duration'] || ''
-  ).split(', ')
-  const animationTimeout: number = getTimeout(
-    animationDelays,
-    animationDurations
-  )
-
-  let type: string | undefined | null
-  let timeout = 0
-  let propCount = 0
-  /* istanbul ignore if */
-  if (expectedType === TRANSITION) {
-    if (transitionTimeout > 0) {
-      type = TRANSITION
-      timeout = transitionTimeout
-      propCount = transitionDurations.length
-    }
-  } else if (expectedType === ANIMATION) {
-    if (animationTimeout > 0) {
-      type = ANIMATION
-      timeout = animationTimeout
-      propCount = animationDurations.length
-    }
-  } else {
-    timeout = Math.max(transitionTimeout, animationTimeout)
-    type =
-      timeout > 0
-        ? transitionTimeout > animationTimeout
-          ? TRANSITION
-          : ANIMATION
-        : null
-    propCount = type
-      ? type === TRANSITION
-        ? transitionDurations.length
-        : animationDurations.length
-      : 0
-  }
-  const hasTransform: boolean =
-    type === TRANSITION && transformRE.test(styles[transitionProp + 'Property'])
-  return {
-    type,
-    timeout,
-    propCount,
-    hasTransform
-  }
-}
-
-function getTimeout(delays: Array<string>, durations: Array<string>): number {
-  /* istanbul ignore next */
-  while (delays.length < durations.length) {
-    delays = delays.concat(delays)
-  }
-
-  return Math.max.apply(
-    null,
-    durations.map((d, i) => {
-      return toMs(d) + toMs(delays[i])
-    })
-  )
-}
-
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s: string): number {
-  return Number(s.slice(0, -1).replace(',', '.')) * 1000
-}