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

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

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

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

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

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

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

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

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