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

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

@@ -1,75 +0,0 @@
-import Vue from 'core/index'
-import config from 'core/config'
-import { extend, noop } from 'shared/util'
-import { mountComponent } from 'core/instance/lifecycle'
-import { devtools, inBrowser } from 'core/util/index'
-
-import {
-  query,
-  mustUseProp,
-  isReservedTag,
-  isReservedAttr,
-  getTagNamespace,
-  isUnknownElement
-} from 'web/util/index'
-
-import { patch } from './patch'
-import platformDirectives from './directives/index'
-import platformComponents from './components/index'
-import type { Component } from 'types/component'
-
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp
-Vue.config.isReservedTag = isReservedTag
-Vue.config.isReservedAttr = isReservedAttr
-Vue.config.getTagNamespace = getTagNamespace
-Vue.config.isUnknownElement = isUnknownElement
-
-// install platform runtime directives & components
-extend(Vue.options.directives, platformDirectives)
-extend(Vue.options.components, platformComponents)
-
-// install platform patch function
-Vue.prototype.__patch__ = inBrowser ? patch : noop
-
-// public mount method
-Vue.prototype.$mount = function (
-  el?: string | Element,
-  hydrating?: boolean
-): Component {
-  el = el && inBrowser ? query(el) : undefined
-  return mountComponent(this, el, hydrating)
-}
-
-// devtools global hook
-/* istanbul ignore next */
-if (inBrowser) {
-  setTimeout(() => {
-    if (config.devtools) {
-      if (devtools) {
-        devtools.emit('init', Vue)
-      } else if (__DEV__ && process.env.NODE_ENV !== 'test') {
-        // @ts-expect-error
-        console[console.info ? 'info' : 'log'](
-          'Download the Vue Devtools extension for a better development experience:\n' +
-            'https://github.com/vuejs/vue-devtools'
-        )
-      }
-    }
-    if (
-      __DEV__ &&
-      process.env.NODE_ENV !== 'test' &&
-      config.productionTip !== false &&
-      typeof console !== 'undefined'
-    ) {
-      // @ts-expect-error
-      console[console.info ? 'info' : 'log'](
-        `You are running Vue in development mode.\n` +
-          `Make sure to turn on production mode when deploying for production.\n` +
-          `See more tips at https://vuejs.org/guide/deployment.html`
-      )
-    }
-  }, 0)
-}
-
-export default Vue

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

@@ -1,115 +0,0 @@
-import { isIE, isIE9, isEdge } from 'core/util/env'
-
-import { extend, isDef, isUndef, isTrue } from 'shared/util'
-import type { VNodeWithData } from 'types/vnode'
-
-import {
-  isXlink,
-  xlinkNS,
-  getXlinkProp,
-  isBooleanAttr,
-  isEnumeratedAttr,
-  isFalsyAttrValue,
-  convertEnumeratedValue
-} from 'web/util/index'
-
-function updateAttrs(oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  const opts = vnode.componentOptions
-  if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-    return
-  }
-  if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-    return
-  }
-  let key, cur, old
-  const elm = vnode.elm
-  const oldAttrs = oldVnode.data.attrs || {}
-  let attrs: any = vnode.data.attrs || {}
-  // clone observed objects, as the user probably wants to mutate it
-  if (isDef(attrs.__ob__) || isTrue(attrs._v_attr_proxy)) {
-    attrs = vnode.data.attrs = extend({}, attrs)
-  }
-
-  for (key in attrs) {
-    cur = attrs[key]
-    old = oldAttrs[key]
-    if (old !== cur) {
-      setAttr(elm, key, cur, vnode.data.pre)
-    }
-  }
-  // #4391: in IE9, setting type can reset value for input[type=radio]
-  // #6666: IE/Edge forces progress value down to 1 before setting a max
-  /* istanbul ignore if */
-  if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-    setAttr(elm, 'value', attrs.value)
-  }
-  for (key in oldAttrs) {
-    if (isUndef(attrs[key])) {
-      if (isXlink(key)) {
-        elm.removeAttributeNS(xlinkNS, getXlinkProp(key))
-      } else if (!isEnumeratedAttr(key)) {
-        elm.removeAttribute(key)
-      }
-    }
-  }
-}
-
-function setAttr(el: Element, key: string, value: any, isInPre?: any) {
-  if (isInPre || el.tagName.indexOf('-') > -1) {
-    baseSetAttr(el, key, value)
-  } else if (isBooleanAttr(key)) {
-    // set attribute for blank value
-    // e.g. <option disabled>Select one</option>
-    if (isFalsyAttrValue(value)) {
-      el.removeAttribute(key)
-    } else {
-      // technically allowfullscreen is a boolean attribute for <iframe>,
-      // but Flash expects a value of "true" when used on <embed> tag
-      value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key
-      el.setAttribute(key, value)
-    }
-  } else if (isEnumeratedAttr(key)) {
-    el.setAttribute(key, convertEnumeratedValue(key, value))
-  } else if (isXlink(key)) {
-    if (isFalsyAttrValue(value)) {
-      el.removeAttributeNS(xlinkNS, getXlinkProp(key))
-    } else {
-      el.setAttributeNS(xlinkNS, key, value)
-    }
-  } else {
-    baseSetAttr(el, key, value)
-  }
-}
-
-function baseSetAttr(el, key, value) {
-  if (isFalsyAttrValue(value)) {
-    el.removeAttribute(key)
-  } else {
-    // #7138: IE10 & 11 fires input event when setting placeholder on
-    // <textarea>... block the first input event and remove the blocker
-    // immediately.
-    /* istanbul ignore if */
-    if (
-      isIE &&
-      !isIE9 &&
-      el.tagName === 'TEXTAREA' &&
-      key === 'placeholder' &&
-      value !== '' &&
-      !el.__ieph
-    ) {
-      const blocker = e => {
-        e.stopImmediatePropagation()
-        el.removeEventListener('input', blocker)
-      }
-      el.addEventListener('input', blocker)
-      // $flow-disable-line
-      el.__ieph = true /* IE placeholder patched */
-    }
-    el.setAttribute(key, value)
-  }
-}
-
-export default {
-  create: updateAttrs,
-  update: updateAttrs
-}

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

@@ -1,37 +0,0 @@
-import { isDef, isUndef } from 'shared/util'
-import type { VNodeData } from 'types/vnode'
-
-import { concat, stringifyClass, genClassForVnode } from 'web/util/index'
-
-function updateClass(oldVnode: any, vnode: any) {
-  const el = vnode.elm
-  const data: VNodeData = vnode.data
-  const oldData: VNodeData = oldVnode.data
-  if (
-    isUndef(data.staticClass) &&
-    isUndef(data.class) &&
-    (isUndef(oldData) ||
-      (isUndef(oldData.staticClass) && isUndef(oldData.class)))
-  ) {
-    return
-  }
-
-  let cls = genClassForVnode(vnode)
-
-  // handle transition classes
-  const transitionClass = el._transitionClasses
-  if (isDef(transitionClass)) {
-    cls = concat(cls, stringifyClass(transitionClass))
-  }
-
-  // set the class
-  if (cls !== el._prevClass) {
-    el.setAttribute('class', cls)
-    el._prevClass = cls
-  }
-}
-
-export default {
-  create: updateClass,
-  update: updateClass
-}

package/vue2/node_modules/vue/src/platforms/web/runtime/modules/dom-props.ts

@@ -1,123 +0,0 @@
-import { isDef, isUndef, extend, toNumber, isTrue } from 'shared/util'
-import type { VNodeWithData } from 'types/vnode'
-import { isSVG } from 'web/util/index'
-
-let svgContainer
-
-function updateDOMProps(oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-    return
-  }
-  let key, cur
-  const elm: any = vnode.elm
-  const oldProps = oldVnode.data.domProps || {}
-  let props = vnode.data.domProps || {}
-  // clone observed objects, as the user probably wants to mutate it
-  if (isDef(props.__ob__) || isTrue(props._v_attr_proxy)) {
-    props = vnode.data.domProps = extend({}, props)
-  }
-
-  for (key in oldProps) {
-    if (!(key in props)) {
-      elm[key] = ''
-    }
-  }
-
-  for (key in props) {
-    cur = props[key]
-    // ignore children if the node has textContent or innerHTML,
-    // as these will throw away existing DOM nodes and cause removal errors
-    // on subsequent patches (#3360)
-    if (key === 'textContent' || key === 'innerHTML') {
-      if (vnode.children) vnode.children.length = 0
-      if (cur === oldProps[key]) continue
-      // #6601 work around Chrome version <= 55 bug where single textNode
-      // replaced by innerHTML/textContent retains its parentNode property
-      if (elm.childNodes.length === 1) {
-        elm.removeChild(elm.childNodes[0])
-      }
-    }
-
-    if (key === 'value' && elm.tagName !== 'PROGRESS') {
-      // store value as _value as well since
-      // non-string values will be stringified
-      elm._value = cur
-      // avoid resetting cursor position when value is the same
-      const strCur = isUndef(cur) ? '' : String(cur)
-      if (shouldUpdateValue(elm, strCur)) {
-        elm.value = strCur
-      }
-    } else if (
-      key === 'innerHTML' &&
-      isSVG(elm.tagName) &&
-      isUndef(elm.innerHTML)
-    ) {
-      // IE doesn't support innerHTML for SVG elements
-      svgContainer = svgContainer || document.createElement('div')
-      svgContainer.innerHTML = `<svg>${cur}</svg>`
-      const svg = svgContainer.firstChild
-      while (elm.firstChild) {
-        elm.removeChild(elm.firstChild)
-      }
-      while (svg.firstChild) {
-        elm.appendChild(svg.firstChild)
-      }
-    } else if (
-      // skip the update if old and new VDOM state is the same.
-      // `value` is handled separately because the DOM value may be temporarily
-      // out of sync with VDOM state due to focus, composition and modifiers.
-      // This  #4521 by skipping the unnecessary `checked` update.
-      cur !== oldProps[key]
-    ) {
-      // some property updates can throw
-      // e.g. `value` on <progress> w/ non-finite value
-      try {
-        elm[key] = cur
-      } catch (e: any) {}
-    }
-  }
-}
-
-// check platforms/web/util/attrs.js acceptValue
-type acceptValueElm = HTMLInputElement | HTMLSelectElement | HTMLOptionElement
-
-function shouldUpdateValue(elm: acceptValueElm, checkVal: string): boolean {
-  return (
-    //@ts-expect-error
-    !elm.composing &&
-    (elm.tagName === 'OPTION' ||
-      isNotInFocusAndDirty(elm, checkVal) ||
-      isDirtyWithModifiers(elm, checkVal))
-  )
-}
-
-function isNotInFocusAndDirty(elm: acceptValueElm, checkVal: string): boolean {
-  // return true when textbox (.number and .trim) loses focus and its value is
-  // not equal to the updated value
-  let notInFocus = true
-  // #6157
-  // work around IE bug when accessing document.activeElement in an iframe
-  try {
-    notInFocus = document.activeElement !== elm
-  } catch (e: any) {}
-  return notInFocus && elm.value !== checkVal
-}
-
-function isDirtyWithModifiers(elm: any, newVal: string): boolean {
-  const value = elm.value
-  const modifiers = elm._vModifiers // injected by v-model runtime
-  if (isDef(modifiers)) {
-    if (modifiers.number) {
-      return toNumber(value) !== toNumber(newVal)
-    }
-    if (modifiers.trim) {
-      return value.trim() !== newVal.trim()
-    }
-  }
-  return value !== newVal
-}
-
-export default {
-  create: updateDOMProps,
-  update: updateDOMProps
-}

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

@@ -1,127 +0,0 @@
-import { isDef, isUndef } from 'shared/util'
-import { updateListeners } from 'core/vdom/helpers/index'
-import { isIE, isFF, supportsPassive, isUsingMicroTask } from 'core/util/index'
-import {
-  RANGE_TOKEN,
-  CHECKBOX_RADIO_TOKEN
-} from 'web/compiler/directives/model'
-import { currentFlushTimestamp } from 'core/observer/scheduler'
-import { emptyNode } from 'core/vdom/patch'
-import type { VNodeWithData } from 'types/vnode'
-
-// normalize v-model event tokens that can only be determined at runtime.
-// it's important to place the event as the first in the array because
-// the whole point is ensuring the v-model callback gets called before
-// user-attached handlers.
-function normalizeEvents(on) {
-  /* istanbul ignore if */
-  if (isDef(on[RANGE_TOKEN])) {
-    // IE input[type=range] only supports `change` event
-    const event = isIE ? 'change' : 'input'
-    on[event] = [].concat(on[RANGE_TOKEN], on[event] || [])
-    delete on[RANGE_TOKEN]
-  }
-  // This was originally intended to fix #4521 but no longer necessary
-  // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-  /* istanbul ignore if */
-  if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-    on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || [])
-    delete on[CHECKBOX_RADIO_TOKEN]
-  }
-}
-
-let target: any
-
-function createOnceHandler(event, handler, capture) {
-  const _target = target // save current target element in closure
-  return function onceHandler() {
-    const res = handler.apply(null, arguments)
-    if (res !== null) {
-      remove(event, onceHandler, capture, _target)
-    }
-  }
-}
-
-// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-// implementation and does not fire microtasks in between event propagation, so
-// safe to exclude.
-const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53)
-
-function add(
-  name: string,
-  handler: Function,
-  capture: boolean,
-  passive: boolean
-) {
-  // async edge case #6566: inner click event triggers patch, event handler
-  // attached to outer element during patch, and triggered again. This
-  // happens because browsers fire microtask ticks between event propagation.
-  // the solution is simple: we save the timestamp when a handler is attached,
-  // and the handler would only fire if the event passed to it was fired
-  // AFTER it was attached.
-  if (useMicrotaskFix) {
-    const attachedTimestamp = currentFlushTimestamp
-    const original = handler
-    //@ts-expect-error
-    handler = original._wrapper = function (e) {
-      if (
-        // no bubbling, should always fire.
-        // this is just a safety net in case event.timeStamp is unreliable in
-        // certain weird environments...
-        e.target === e.currentTarget ||
-        // event is fired after handler attachment
-        e.timeStamp >= attachedTimestamp ||
-        // bail for environments that have buggy event.timeStamp implementations
-        // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-        // #9681 QtWebEngine event.timeStamp is negative value
-        e.timeStamp <= 0 ||
-        // #9448 bail if event is fired in another document in a multi-page
-        // electron/nw.js app, since event.timeStamp will be using a different
-        // starting reference
-        e.target.ownerDocument !== document
-      ) {
-        return original.apply(this, arguments)
-      }
-    }
-  }
-  target.addEventListener(
-    name,
-    handler,
-    supportsPassive ? { capture, passive } : capture
-  )
-}
-
-function remove(
-  name: string,
-  handler: Function,
-  capture: boolean,
-  _target?: HTMLElement
-) {
-  ;(_target || target).removeEventListener(
-    name,
-    //@ts-expect-error
-    handler._wrapper || handler,
-    capture
-  )
-}
-
-function updateDOMListeners(oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-    return
-  }
-  const on = vnode.data.on || {}
-  const oldOn = oldVnode.data.on || {}
-  // vnode is empty when removing all listeners,
-  // and use old vnode dom element
-  target = vnode.elm || oldVnode.elm
-  normalizeEvents(on)
-  updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context)
-  target = undefined
-}
-
-export default {
-  create: updateDOMListeners,
-  update: updateDOMListeners,
-  // @ts-expect-error emptyNode has actually data
-  destroy: (vnode: VNodeWithData) => updateDOMListeners(vnode, emptyNode)
-}

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

@@ -1,8 +0,0 @@
-import attrs from './attrs'
-import klass from './class'
-import events from './events'
-import domProps from './dom-props'
-import style from './style'
-import transition from './transition'
-
-export default [attrs, klass, events, domProps, style, transition]

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

@@ -1,104 +0,0 @@
-import { getStyle, normalizeStyleBinding } from 'web/util/style'
-import {
-  cached,
-  camelize,
-  extend,
-  isDef,
-  isUndef,
-  hyphenate
-} from 'shared/util'
-import type { VNodeWithData } from 'types/vnode'
-
-const cssVarRE = /^--/
-const importantRE = /\s*!important$/
-const setProp = (el, name, val) => {
-  /* istanbul ignore if */
-  if (cssVarRE.test(name)) {
-    el.style.setProperty(name, val)
-  } else if (importantRE.test(val)) {
-    el.style.setProperty(
-      hyphenate(name),
-      val.replace(importantRE, ''),
-      'important'
-    )
-  } else {
-    const normalizedName = normalize(name)
-    if (Array.isArray(val)) {
-      // Support values array created by autoprefixer, e.g.
-      // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-      // Set them one by one, and the browser will only set those it can recognize
-      for (let i = 0, len = val.length; i < len; i++) {
-        el.style[normalizedName!] = val[i]
-      }
-    } else {
-      el.style[normalizedName!] = val
-    }
-  }
-}
-
-const vendorNames = ['Webkit', 'Moz', 'ms']
-
-let emptyStyle
-const normalize = cached(function (prop) {
-  emptyStyle = emptyStyle || document.createElement('div').style
-  prop = camelize(prop)
-  if (prop !== 'filter' && prop in emptyStyle) {
-    return prop
-  }
-  const capName = prop.charAt(0).toUpperCase() + prop.slice(1)
-  for (let i = 0; i < vendorNames.length; i++) {
-    const name = vendorNames[i] + capName
-    if (name in emptyStyle) {
-      return name
-    }
-  }
-})
-
-function updateStyle(oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  const data = vnode.data
-  const oldData = oldVnode.data
-
-  if (
-    isUndef(data.staticStyle) &&
-    isUndef(data.style) &&
-    isUndef(oldData.staticStyle) &&
-    isUndef(oldData.style)
-  ) {
-    return
-  }
-
-  let cur, name
-  const el: any = vnode.elm
-  const oldStaticStyle: any = oldData.staticStyle
-  const oldStyleBinding: any = oldData.normalizedStyle || oldData.style || {}
-
-  // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-  const oldStyle = oldStaticStyle || oldStyleBinding
-
-  const style = normalizeStyleBinding(vnode.data.style) || {}
-
-  // store normalized style under a different key for next diff
-  // make sure to clone it if it's reactive, since the user likely wants
-  // to mutate it.
-  vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style
-
-  const newStyle = getStyle(vnode, true)
-
-  for (name in oldStyle) {
-    if (isUndef(newStyle[name])) {
-      setProp(el, name, '')
-    }
-  }
-  for (name in newStyle) {
-    cur = newStyle[name]
-    if (cur !== oldStyle[name]) {
-      // ie9 setting to null has no effect, must use empty string
-      setProp(el, name, cur == null ? '' : cur)
-    }
-  }
-}
-
-export default {
-  create: updateStyle,
-  update: updateStyle
-}