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

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

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

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

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

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