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

package/vue2/node_modules/vue/src/core/instance/lifecycle.ts

@@ -0,0 +1,415 @@
+import config from '../config'
+import Watcher, { WatcherOptions } from '../observer/watcher'
+import { mark, measure } from '../util/perf'
+import VNode, { createEmptyVNode } from '../vdom/vnode'
+import { updateComponentListeners } from './events'
+import { resolveSlots } from './render-helpers/resolve-slots'
+import { toggleObserving } from '../observer/index'
+import { pushTarget, popTarget } from '../observer/dep'
+import type { Component } from 'types/component'
+import type { MountedComponentVNode } from 'types/vnode'
+
+import {
+  warn,
+  noop,
+  remove,
+  emptyObject,
+  validateProp,
+  invokeWithErrorHandling
+} from '../util/index'
+import { currentInstance, setCurrentInstance } from 'v3/currentInstance'
+import { syncSetupProxy } from 'v3/apiSetup'
+
+export let activeInstance: any = null
+export let isUpdatingChildComponent: boolean = false
+
+export function setActiveInstance(vm: Component) {
+  const prevActiveInstance = activeInstance
+  activeInstance = vm
+  return () => {
+    activeInstance = prevActiveInstance
+  }
+}
+
+export function initLifecycle(vm: Component) {
+  const options = vm.$options
+
+  // locate first non-abstract parent
+  let parent = options.parent
+  if (parent && !options.abstract) {
+    while (parent.$options.abstract && parent.$parent) {
+      parent = parent.$parent
+    }
+    parent.$children.push(vm)
+  }
+
+  vm.$parent = parent
+  vm.$root = parent ? parent.$root : vm
+
+  vm.$children = []
+  vm.$refs = {}
+
+  vm._provided = parent ? parent._provided : Object.create(null)
+  vm._watcher = null
+  vm._inactive = null
+  vm._directInactive = false
+  vm._isMounted = false
+  vm._isDestroyed = false
+  vm._isBeingDestroyed = false
+}
+
+export function lifecycleMixin(Vue: typeof Component) {
+  Vue.prototype._update = function (vnode: VNode, hydrating?: boolean) {
+    const vm: Component = this
+    const prevEl = vm.$el
+    const prevVnode = vm._vnode
+    const restoreActiveInstance = setActiveInstance(vm)
+    vm._vnode = vnode
+    // Vue.prototype.__patch__ is injected in entry points
+    // based on the rendering backend used.
+    if (!prevVnode) {
+      // initial render
+      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */)
+    } else {
+      // updates
+      vm.$el = vm.__patch__(prevVnode, vnode)
+    }
+    restoreActiveInstance()
+    // update __vue__ reference
+    if (prevEl) {
+      prevEl.__vue__ = null
+    }
+    if (vm.$el) {
+      vm.$el.__vue__ = vm
+    }
+    // if parent is an HOC, update its $el as well
+    let wrapper: Component | undefined = vm
+    while (
+      wrapper &&
+      wrapper.$vnode &&
+      wrapper.$parent &&
+      wrapper.$vnode === wrapper.$parent._vnode
+    ) {
+      wrapper.$parent.$el = wrapper.$el
+      wrapper = wrapper.$parent
+    }
+    // updated hook is called by the scheduler to ensure that children are
+    // updated in a parent's updated hook.
+  }
+
+  Vue.prototype.$forceUpdate = function () {
+    const vm: Component = this
+    if (vm._watcher) {
+      vm._watcher.update()
+    }
+  }
+
+  Vue.prototype.$destroy = function () {
+    const vm: Component = this
+    if (vm._isBeingDestroyed) {
+      return
+    }
+    callHook(vm, 'beforeDestroy')
+    vm._isBeingDestroyed = true
+    // remove self from parent
+    const parent = vm.$parent
+    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+      remove(parent.$children, vm)
+    }
+    // teardown scope. this includes both the render watcher and other
+    // watchers created
+    vm._scope.stop()
+    // remove reference from data ob
+    // frozen object may not have observer.
+    if (vm._data.__ob__) {
+      vm._data.__ob__.vmCount--
+    }
+    // call the last hook...
+    vm._isDestroyed = true
+    // invoke destroy hooks on current rendered tree
+    vm.__patch__(vm._vnode, null)
+    // fire destroyed hook
+    callHook(vm, 'destroyed')
+    // turn off all instance listeners.
+    vm.$off()
+    // remove __vue__ reference
+    if (vm.$el) {
+      vm.$el.__vue__ = null
+    }
+    // release circular reference (#6759)
+    if (vm.$vnode) {
+      vm.$vnode.parent = null
+    }
+  }
+}
+
+export function mountComponent(
+  vm: Component,
+  el: Element | null | undefined,
+  hydrating?: boolean
+): Component {
+  vm.$el = el
+  if (!vm.$options.render) {
+    // @ts-expect-error invalid type
+    vm.$options.render = createEmptyVNode
+    if (__DEV__) {
+      /* istanbul ignore if */
+      if (
+        (vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+        vm.$options.el ||
+        el
+      ) {
+        warn(
+          'You are using the runtime-only build of Vue where the template ' +
+            'compiler is not available. Either pre-compile the templates into ' +
+            'render functions, or use the compiler-included build.',
+          vm
+        )
+      } else {
+        warn(
+          'Failed to mount component: template or render function not defined.',
+          vm
+        )
+      }
+    }
+  }
+  callHook(vm, 'beforeMount')
+
+  let updateComponent
+  /* istanbul ignore if */
+  if (__DEV__ && config.performance && mark) {
+    updateComponent = () => {
+      const name = vm._name
+      const id = vm._uid
+      const startTag = `vue-perf-start:${id}`
+      const endTag = `vue-perf-end:${id}`
+
+      mark(startTag)
+      const vnode = vm._render()
+      mark(endTag)
+      measure(`vue ${name} render`, startTag, endTag)
+
+      mark(startTag)
+      vm._update(vnode, hydrating)
+      mark(endTag)
+      measure(`vue ${name} patch`, startTag, endTag)
+    }
+  } else {
+    updateComponent = () => {
+      vm._update(vm._render(), hydrating)
+    }
+  }
+
+  const watcherOptions: WatcherOptions = {
+    before() {
+      if (vm._isMounted && !vm._isDestroyed) {
+        callHook(vm, 'beforeUpdate')
+      }
+    }
+  }
+
+  if (__DEV__) {
+    watcherOptions.onTrack = e => callHook(vm, 'renderTracked', [e])
+    watcherOptions.onTrigger = e => callHook(vm, 'renderTriggered', [e])
+  }
+
+  // we set this to vm._watcher inside the watcher's constructor
+  // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+  // component's mounted hook), which relies on vm._watcher being already defined
+  new Watcher(
+    vm,
+    updateComponent,
+    noop,
+    watcherOptions,
+    true /* isRenderWatcher */
+  )
+  hydrating = false
+
+  // flush buffer for flush: "pre" watchers queued in setup()
+  const preWatchers = vm._preWatchers
+  if (preWatchers) {
+    for (let i = 0; i < preWatchers.length; i++) {
+      preWatchers[i].run()
+    }
+  }
+
+  // manually mounted instance, call mounted on self
+  // mounted is called for render-created child components in its inserted hook
+  if (vm.$vnode == null) {
+    vm._isMounted = true
+    callHook(vm, 'mounted')
+  }
+  return vm
+}
+
+export function updateChildComponent(
+  vm: Component,
+  propsData: Record<string, any> | null | undefined,
+  listeners: Record<string, Function | Array<Function>> | undefined,
+  parentVnode: MountedComponentVNode,
+  renderChildren?: Array<VNode> | null
+) {
+  if (__DEV__) {
+    isUpdatingChildComponent = true
+  }
+
+  // determine whether component has slot children
+  // we need to do this before overwriting $options._renderChildren.
+
+  // check if there are dynamic scopedSlots (hand-written or compiled but with
+  // dynamic slot names). Static scoped slots compiled from template has the
+  // "$stable" marker.
+  const newScopedSlots = parentVnode.data.scopedSlots
+  const oldScopedSlots = vm.$scopedSlots
+  const hasDynamicScopedSlot = !!(
+    (newScopedSlots && !newScopedSlots.$stable) ||
+    (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+    (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+    (!newScopedSlots && vm.$scopedSlots.$key)
+  )
+
+  // Any static slot children from the parent may have changed during parent's
+  // update. Dynamic scoped slots may also have changed. In such cases, a forced
+  // update is necessary to ensure correctness.
+  let needsForceUpdate = !!(
+    renderChildren || // has new static slots
+    vm.$options._renderChildren || // has old static slots
+    hasDynamicScopedSlot
+  )
+
+  const prevVNode = vm.$vnode
+  vm.$options._parentVnode = parentVnode
+  vm.$vnode = parentVnode // update vm's placeholder node without re-render
+
+  if (vm._vnode) {
+    // update child tree's parent
+    vm._vnode.parent = parentVnode
+  }
+  vm.$options._renderChildren = renderChildren
+
+  // update $attrs and $listeners hash
+  // these are also reactive so they may trigger child update if the child
+  // used them during render
+  const attrs = parentVnode.data.attrs || emptyObject
+  if (vm._attrsProxy) {
+    // force update if attrs are accessed and has changed since it may be
+    // passed to a child component.
+    if (
+      syncSetupProxy(
+        vm._attrsProxy,
+        attrs,
+        (prevVNode.data && prevVNode.data.attrs) || emptyObject,
+        vm,
+        '$attrs'
+      )
+    ) {
+      needsForceUpdate = true
+    }
+  }
+  vm.$attrs = attrs
+
+  // update listeners
+  listeners = listeners || emptyObject
+  const prevListeners = vm.$options._parentListeners
+  if (vm._listenersProxy) {
+    syncSetupProxy(
+      vm._listenersProxy,
+      listeners,
+      prevListeners || emptyObject,
+      vm,
+      '$listeners'
+    )
+  }
+  vm.$listeners = vm.$options._parentListeners = listeners
+  updateComponentListeners(vm, listeners, prevListeners)
+
+  // update props
+  if (propsData && vm.$options.props) {
+    toggleObserving(false)
+    const props = vm._props
+    const propKeys = vm.$options._propKeys || []
+    for (let i = 0; i < propKeys.length; i++) {
+      const key = propKeys[i]
+      const propOptions: any = vm.$options.props // wtf flow?
+      props[key] = validateProp(key, propOptions, propsData, vm)
+    }
+    toggleObserving(true)
+    // keep a copy of raw propsData
+    vm.$options.propsData = propsData
+  }
+
+  // resolve slots + force update if has children
+  if (needsForceUpdate) {
+    vm.$slots = resolveSlots(renderChildren, parentVnode.context)
+    vm.$forceUpdate()
+  }
+
+  if (__DEV__) {
+    isUpdatingChildComponent = false
+  }
+}
+
+function isInInactiveTree(vm) {
+  while (vm && (vm = vm.$parent)) {
+    if (vm._inactive) return true
+  }
+  return false
+}
+
+export function activateChildComponent(vm: Component, direct?: boolean) {
+  if (direct) {
+    vm._directInactive = false
+    if (isInInactiveTree(vm)) {
+      return
+    }
+  } else if (vm._directInactive) {
+    return
+  }
+  if (vm._inactive || vm._inactive === null) {
+    vm._inactive = false
+    for (let i = 0; i < vm.$children.length; i++) {
+      activateChildComponent(vm.$children[i])
+    }
+    callHook(vm, 'activated')
+  }
+}
+
+export function deactivateChildComponent(vm: Component, direct?: boolean) {
+  if (direct) {
+    vm._directInactive = true
+    if (isInInactiveTree(vm)) {
+      return
+    }
+  }
+  if (!vm._inactive) {
+    vm._inactive = true
+    for (let i = 0; i < vm.$children.length; i++) {
+      deactivateChildComponent(vm.$children[i])
+    }
+    callHook(vm, 'deactivated')
+  }
+}
+
+export function callHook(
+  vm: Component,
+  hook: string,
+  args?: any[],
+  setContext = true
+) {
+  // #7573 disable dep collection when invoking lifecycle hooks
+  pushTarget()
+  const prev = currentInstance
+  setContext && setCurrentInstance(vm)
+  const handlers = vm.$options[hook]
+  const info = `${hook} hook`
+  if (handlers) {
+    for (let i = 0, j = handlers.length; i < j; i++) {
+      invokeWithErrorHandling(handlers[i], vm, args || null, vm, info)
+    }
+  }
+  if (vm._hasHookEvent) {
+    vm.$emit('hook:' + hook)
+  }
+  setContext && setCurrentInstance(prev)
+  popTarget()
+}

package/vue2/node_modules/vue/src/core/instance/proxy.ts

@@ -0,0 +1,97 @@
+/* not type checking this file because flow doesn't play well with Proxy */
+
+import config from 'core/config'
+import { warn, makeMap, isNative } from '../util/index'
+
+let initProxy
+
+if (__DEV__) {
+  const allowedGlobals = makeMap(
+    'Infinity,undefined,NaN,isFinite,isNaN,' +
+      'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+      'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+      'require' // for Webpack/Browserify
+  )
+
+  const warnNonPresent = (target, key) => {
+    warn(
+      `Property or method "${key}" is not defined on the instance but ` +
+        'referenced during render. Make sure that this property is reactive, ' +
+        'either in the data option, or for class-based components, by ' +
+        'initializing the property. ' +
+        'See: https://v2.vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
+      target
+    )
+  }
+
+  const warnReservedPrefix = (target, key) => {
+    warn(
+      `Property "${key}" must be accessed with "$data.${key}" because ` +
+        'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+        'prevent conflicts with Vue internals. ' +
+        'See: https://v2.vuejs.org/v2/api/#data',
+      target
+    )
+  }
+
+  const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy)
+
+  if (hasProxy) {
+    const isBuiltInModifier = makeMap(
+      'stop,prevent,self,ctrl,shift,alt,meta,exact'
+    )
+    config.keyCodes = new Proxy(config.keyCodes, {
+      set(target, key: string, value) {
+        if (isBuiltInModifier(key)) {
+          warn(
+            `Avoid overwriting built-in modifier in config.keyCodes: .${key}`
+          )
+          return false
+        } else {
+          target[key] = value
+          return true
+        }
+      }
+    })
+  }
+
+  const hasHandler = {
+    has(target, key) {
+      const has = key in target
+      const isAllowed =
+        allowedGlobals(key) ||
+        (typeof key === 'string' &&
+          key.charAt(0) === '_' &&
+          !(key in target.$data))
+      if (!has && !isAllowed) {
+        if (key in target.$data) warnReservedPrefix(target, key)
+        else warnNonPresent(target, key)
+      }
+      return has || !isAllowed
+    }
+  }
+
+  const getHandler = {
+    get(target, key) {
+      if (typeof key === 'string' && !(key in target)) {
+        if (key in target.$data) warnReservedPrefix(target, key)
+        else warnNonPresent(target, key)
+      }
+      return target[key]
+    }
+  }
+
+  initProxy = function initProxy(vm) {
+    if (hasProxy) {
+      // determine which proxy handler to use
+      const options = vm.$options
+      const handlers =
+        options.render && options.render._withStripped ? getHandler : hasHandler
+      vm._renderProxy = new Proxy(vm, handlers)
+    } else {
+      vm._renderProxy = vm
+    }
+  }
+}
+
+export { initProxy }

package/vue2/node_modules/vue/src/core/instance/render-helpers/bind-dynamic-keys.ts

@@ -0,0 +1,36 @@
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+// For example, the following template:
+//
+// <div id="app" :[key]="value">
+//
+// compiles to the following:
+//
+// _c('div', { attrs: bindDynamicKeys({ "id": "app" }, [key, value]) })
+
+import { warn } from 'core/util/debug'
+
+export function bindDynamicKeys(
+  baseObj: Record<string, any>,
+  values: Array<any>
+): Object {
+  for (let i = 0; i < values.length; i += 2) {
+    const key = values[i]
+    if (typeof key === 'string' && key) {
+      baseObj[values[i]] = values[i + 1]
+    } else if (__DEV__ && key !== '' && key !== null) {
+      // null is a special value for explicitly removing a binding
+      warn(
+        `Invalid value for dynamic directive argument (expected string or null): ${key}`,
+        this
+      )
+    }
+  }
+  return baseObj
+}
+
+// helper to dynamically append modifier runtime markers to event names.
+// ensure only append when value is already string, otherwise it will be cast
+// to string and cause the type check to miss.
+export function prependModifier(value: any, symbol: string): any {
+  return typeof value === 'string' ? symbol + value : value
+}

package/vue2/node_modules/vue/src/core/instance/render-helpers/bind-object-listeners.ts

@@ -0,0 +1,18 @@
+import { warn, extend, isPlainObject } from 'core/util/index'
+import type { VNodeData } from 'types/vnode'
+
+export function bindObjectListeners(data: any, value: any): VNodeData {
+  if (value) {
+    if (!isPlainObject(value)) {
+      __DEV__ && warn('v-on without argument expects an Object value', this)
+    } else {
+      const on = (data.on = data.on ? extend({}, data.on) : {})
+      for (const key in value) {
+        const existing = on[key]
+        const ours = value[key]
+        on[key] = existing ? [].concat(existing, ours) : ours
+      }
+    }
+  }
+  return data
+}

package/vue2/node_modules/vue/src/core/instance/render-helpers/bind-object-props.ts

@@ -0,0 +1,59 @@
+import config from 'core/config'
+
+import {
+  warn,
+  isObject,
+  toObject,
+  isReservedAttribute,
+  camelize,
+  hyphenate,
+  isArray
+} from 'core/util/index'
+import type { VNodeData } from 'types/vnode'
+
+/**
+ * Runtime helper for merging v-bind="object" into a VNode's data.
+ */
+export function bindObjectProps(
+  data: any,
+  tag: string,
+  value: any,
+  asProp: boolean,
+  isSync?: boolean
+): VNodeData {
+  if (value) {
+    if (!isObject(value)) {
+      __DEV__ &&
+        warn('v-bind without argument expects an Object or Array value', this)
+    } else {
+      if (isArray(value)) {
+        value = toObject(value)
+      }
+      let hash
+      for (const key in value) {
+        if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+          hash = data
+        } else {
+          const type = data.attrs && data.attrs.type
+          hash =
+            asProp || config.mustUseProp(tag, type, key)
+              ? data.domProps || (data.domProps = {})
+              : data.attrs || (data.attrs = {})
+        }
+        const camelizedKey = camelize(key)
+        const hyphenatedKey = hyphenate(key)
+        if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+          hash[key] = value[key]
+
+          if (isSync) {
+            const on = data.on || (data.on = {})
+            on[`update:${key}`] = function ($event) {
+              value[key] = $event
+            }
+          }
+        }
+      }
+    }
+  }
+  return data
+}

package/vue2/node_modules/vue/src/core/instance/render-helpers/check-keycodes.ts

@@ -0,0 +1,33 @@
+import config from 'core/config'
+import { hyphenate, isArray } from 'shared/util'
+
+function isKeyNotMatch<T>(expect: T | Array<T>, actual: T): boolean {
+  if (isArray(expect)) {
+    return expect.indexOf(actual) === -1
+  } else {
+    return expect !== actual
+  }
+}
+
+/**
+ * Runtime helper for checking keyCodes from config.
+ * exposed as Vue.prototype._k
+ * passing in eventKeyName as last argument separately for backwards compat
+ */
+export function checkKeyCodes(
+  eventKeyCode: number,
+  key: string,
+  builtInKeyCode?: number | Array<number>,
+  eventKeyName?: string,
+  builtInKeyName?: string | Array<string>
+): boolean | null | undefined {
+  const mappedKeyCode = config.keyCodes[key] || builtInKeyCode
+  if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+    return isKeyNotMatch(builtInKeyName, eventKeyName)
+  } else if (mappedKeyCode) {
+    return isKeyNotMatch(mappedKeyCode, eventKeyCode)
+  } else if (eventKeyName) {
+    return hyphenate(eventKeyName) !== key
+  }
+  return eventKeyCode === undefined
+}

package/vue2/node_modules/vue/src/core/instance/render-helpers/index.ts

@@ -0,0 +1,31 @@
+import { toNumber, toString, looseEqual, looseIndexOf } from 'shared/util'
+import { createTextVNode, createEmptyVNode } from 'core/vdom/vnode'
+import { renderList } from './render-list'
+import { renderSlot } from './render-slot'
+import { resolveFilter } from './resolve-filter'
+import { checkKeyCodes } from './check-keycodes'
+import { bindObjectProps } from './bind-object-props'
+import { renderStatic, markOnce } from './render-static'
+import { bindObjectListeners } from './bind-object-listeners'
+import { resolveScopedSlots } from './resolve-scoped-slots'
+import { bindDynamicKeys, prependModifier } from './bind-dynamic-keys'
+
+export function installRenderHelpers(target: any) {
+  target._o = markOnce
+  target._n = toNumber
+  target._s = toString
+  target._l = renderList
+  target._t = renderSlot
+  target._q = looseEqual
+  target._i = looseIndexOf
+  target._m = renderStatic
+  target._f = resolveFilter
+  target._k = checkKeyCodes
+  target._b = bindObjectProps
+  target._v = createTextVNode
+  target._e = createEmptyVNode
+  target._u = resolveScopedSlots
+  target._g = bindObjectListeners
+  target._d = bindDynamicKeys
+  target._p = prependModifier
+}