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

package/vue2/node_modules/vue/src/core/index.ts

@@ -1,27 +0,0 @@
-import Vue from './instance/index'
-import { initGlobalAPI } from './global-api/index'
-import { isServerRendering } from 'core/util/env'
-import { FunctionalRenderContext } from 'core/vdom/create-functional-component'
-import { version } from 'v3'
-
-initGlobalAPI(Vue)
-
-Object.defineProperty(Vue.prototype, '$isServer', {
-  get: isServerRendering
-})
-
-Object.defineProperty(Vue.prototype, '$ssrContext', {
-  get() {
-    /* istanbul ignore next */
-    return this.$vnode && this.$vnode.ssrContext
-  }
-})
-
-// expose FunctionalRenderContext for ssr runtime helper installation
-Object.defineProperty(Vue, 'FunctionalRenderContext', {
-  value: FunctionalRenderContext
-})
-
-Vue.version = version
-
-export default Vue

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

@@ -1,160 +0,0 @@
-import type { Component } from 'types/component'
-import {
-  tip,
-  toArray,
-  isArray,
-  hyphenate,
-  formatComponentName,
-  invokeWithErrorHandling
-} from '../util/index'
-import { updateListeners } from '../vdom/helpers/index'
-
-export function initEvents(vm: Component) {
-  vm._events = Object.create(null)
-  vm._hasHookEvent = false
-  // init parent attached events
-  const listeners = vm.$options._parentListeners
-  if (listeners) {
-    updateComponentListeners(vm, listeners)
-  }
-}
-
-let target: any
-
-function add(event, fn) {
-  target.$on(event, fn)
-}
-
-function remove(event, fn) {
-  target.$off(event, fn)
-}
-
-function createOnceHandler(event, fn) {
-  const _target = target
-  return function onceHandler() {
-    const res = fn.apply(null, arguments)
-    if (res !== null) {
-      _target.$off(event, onceHandler)
-    }
-  }
-}
-
-export function updateComponentListeners(
-  vm: Component,
-  listeners: Object,
-  oldListeners?: Object | null
-) {
-  target = vm
-  updateListeners(
-    listeners,
-    oldListeners || {},
-    add,
-    remove,
-    createOnceHandler,
-    vm
-  )
-  target = undefined
-}
-
-export function eventsMixin(Vue: typeof Component) {
-  const hookRE = /^hook:/
-  Vue.prototype.$on = function (
-    event: string | Array<string>,
-    fn: Function
-  ): Component {
-    const vm: Component = this
-    if (isArray(event)) {
-      for (let i = 0, l = event.length; i < l; i++) {
-        vm.$on(event[i], fn)
-      }
-    } else {
-      ;(vm._events[event] || (vm._events[event] = [])).push(fn)
-      // optimize hook:event cost by using a boolean flag marked at registration
-      // instead of a hash lookup
-      if (hookRE.test(event)) {
-        vm._hasHookEvent = true
-      }
-    }
-    return vm
-  }
-
-  Vue.prototype.$once = function (event: string, fn: Function): Component {
-    const vm: Component = this
-    function on() {
-      vm.$off(event, on)
-      fn.apply(vm, arguments)
-    }
-    on.fn = fn
-    vm.$on(event, on)
-    return vm
-  }
-
-  Vue.prototype.$off = function (
-    event?: string | Array<string>,
-    fn?: Function
-  ): Component {
-    const vm: Component = this
-    // all
-    if (!arguments.length) {
-      vm._events = Object.create(null)
-      return vm
-    }
-    // array of events
-    if (isArray(event)) {
-      for (let i = 0, l = event.length; i < l; i++) {
-        vm.$off(event[i], fn)
-      }
-      return vm
-    }
-    // specific event
-    const cbs = vm._events[event!]
-    if (!cbs) {
-      return vm
-    }
-    if (!fn) {
-      vm._events[event!] = null
-      return vm
-    }
-    // specific handler
-    let cb
-    let i = cbs.length
-    while (i--) {
-      cb = cbs[i]
-      if (cb === fn || cb.fn === fn) {
-        cbs.splice(i, 1)
-        break
-      }
-    }
-    return vm
-  }
-
-  Vue.prototype.$emit = function (event: string): Component {
-    const vm: Component = this
-    if (__DEV__) {
-      const lowerCaseEvent = event.toLowerCase()
-      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-        tip(
-          `Event "${lowerCaseEvent}" is emitted in component ` +
-            `${formatComponentName(
-              vm
-            )} but the handler is registered for "${event}". ` +
-            `Note that HTML attributes are case-insensitive and you cannot use ` +
-            `v-on to listen to camelCase events when using in-DOM templates. ` +
-            `You should probably use "${hyphenate(
-              event
-            )}" instead of "${event}".`
-        )
-      }
-    }
-    let cbs = vm._events[event]
-    if (cbs) {
-      cbs = cbs.length > 1 ? toArray(cbs) : cbs
-      const args = toArray(arguments, 1)
-      const info = `event handler for "${event}"`
-      for (let i = 0, l = cbs.length; i < l; i++) {
-        invokeWithErrorHandling(cbs[i], vm, args, vm, info)
-      }
-    }
-    return vm
-  }
-}

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

@@ -1,27 +0,0 @@
-import { initMixin } from './init'
-import { stateMixin } from './state'
-import { renderMixin } from './render'
-import { eventsMixin } from './events'
-import { lifecycleMixin } from './lifecycle'
-import { warn } from '../util/index'
-import type { GlobalAPI } from 'types/global-api'
-
-function Vue(options) {
-  if (__DEV__ && !(this instanceof Vue)) {
-    warn('Vue is a constructor and should be called with the `new` keyword')
-  }
-  this._init(options)
-}
-
-//@ts-expect-error Vue has function type
-initMixin(Vue)
-//@ts-expect-error Vue has function type
-stateMixin(Vue)
-//@ts-expect-error Vue has function type
-eventsMixin(Vue)
-//@ts-expect-error Vue has function type
-lifecycleMixin(Vue)
-//@ts-expect-error Vue has function type
-renderMixin(Vue)
-
-export default Vue as unknown as GlobalAPI

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

@@ -1,140 +0,0 @@
-import config from '../config'
-import { initProxy } from './proxy'
-import { initState } from './state'
-import { initRender } from './render'
-import { initEvents } from './events'
-import { mark, measure } from '../util/perf'
-import { initLifecycle, callHook } from './lifecycle'
-import { initProvide, initInjections } from './inject'
-import { extend, mergeOptions, formatComponentName } from '../util/index'
-import type { Component } from 'types/component'
-import type { InternalComponentOptions } from 'types/options'
-import { EffectScope } from 'v3/reactivity/effectScope'
-
-let uid = 0
-
-export function initMixin(Vue: typeof Component) {
-  Vue.prototype._init = function (options?: Record<string, any>) {
-    const vm: Component = this
-    // a uid
-    vm._uid = uid++
-
-    let startTag, endTag
-    /* istanbul ignore if */
-    if (__DEV__ && config.performance && mark) {
-      startTag = `vue-perf-start:${vm._uid}`
-      endTag = `vue-perf-end:${vm._uid}`
-      mark(startTag)
-    }
-
-    // a flag to mark this as a Vue instance without having to do instanceof
-    // check
-    vm._isVue = true
-    // avoid instances from being observed
-    vm.__v_skip = true
-    // effect scope
-    vm._scope = new EffectScope(true /* detached */)
-    vm._scope._vm = true
-    // merge options
-    if (options && options._isComponent) {
-      // optimize internal component instantiation
-      // since dynamic options merging is pretty slow, and none of the
-      // internal component options needs special treatment.
-      initInternalComponent(vm, options as any)
-    } else {
-      vm.$options = mergeOptions(
-        resolveConstructorOptions(vm.constructor as any),
-        options || {},
-        vm
-      )
-    }
-    /* istanbul ignore else */
-    if (__DEV__) {
-      initProxy(vm)
-    } else {
-      vm._renderProxy = vm
-    }
-    // expose real self
-    vm._self = vm
-    initLifecycle(vm)
-    initEvents(vm)
-    initRender(vm)
-    callHook(vm, 'beforeCreate', undefined, false /* setContext */)
-    initInjections(vm) // resolve injections before data/props
-    initState(vm)
-    initProvide(vm) // resolve provide after data/props
-    callHook(vm, 'created')
-
-    /* istanbul ignore if */
-    if (__DEV__ && config.performance && mark) {
-      vm._name = formatComponentName(vm, false)
-      mark(endTag)
-      measure(`vue ${vm._name} init`, startTag, endTag)
-    }
-
-    if (vm.$options.el) {
-      vm.$mount(vm.$options.el)
-    }
-  }
-}
-
-export function initInternalComponent(
-  vm: Component,
-  options: InternalComponentOptions
-) {
-  const opts = (vm.$options = Object.create((vm.constructor as any).options))
-  // doing this because it's faster than dynamic enumeration.
-  const parentVnode = options._parentVnode
-  opts.parent = options.parent
-  opts._parentVnode = parentVnode
-
-  const vnodeComponentOptions = parentVnode.componentOptions!
-  opts.propsData = vnodeComponentOptions.propsData
-  opts._parentListeners = vnodeComponentOptions.listeners
-  opts._renderChildren = vnodeComponentOptions.children
-  opts._componentTag = vnodeComponentOptions.tag
-
-  if (options.render) {
-    opts.render = options.render
-    opts.staticRenderFns = options.staticRenderFns
-  }
-}
-
-export function resolveConstructorOptions(Ctor: typeof Component) {
-  let options = Ctor.options
-  if (Ctor.super) {
-    const superOptions = resolveConstructorOptions(Ctor.super)
-    const cachedSuperOptions = Ctor.superOptions
-    if (superOptions !== cachedSuperOptions) {
-      // super option changed,
-      // need to resolve new options.
-      Ctor.superOptions = superOptions
-      // check if there are any late-modified/attached options (#4976)
-      const modifiedOptions = resolveModifiedOptions(Ctor)
-      // update base extend options
-      if (modifiedOptions) {
-        extend(Ctor.extendOptions, modifiedOptions)
-      }
-      options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions)
-      if (options.name) {
-        options.components[options.name] = Ctor
-      }
-    }
-  }
-  return options
-}
-
-function resolveModifiedOptions(
-  Ctor: typeof Component
-): Record<string, any> | null {
-  let modified
-  const latest = Ctor.options
-  const sealed = Ctor.sealedOptions
-  for (const key in latest) {
-    if (latest[key] !== sealed[key]) {
-      if (!modified) modified = {}
-      modified[key] = latest[key]
-    }
-  }
-  return modified
-}

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

@@ -1,80 +0,0 @@
-import { warn, hasSymbol, isFunction, isObject } from '../util/index'
-import { defineReactive, toggleObserving } from '../observer/index'
-import type { Component } from 'types/component'
-import { resolveProvided } from 'v3/apiInject'
-
-export function initProvide(vm: Component) {
-  const provideOption = vm.$options.provide
-  if (provideOption) {
-    const provided = isFunction(provideOption)
-      ? provideOption.call(vm)
-      : provideOption
-    if (!isObject(provided)) {
-      return
-    }
-    const source = resolveProvided(vm)
-    // IE9 doesn't support Object.getOwnPropertyDescriptors so we have to
-    // iterate the keys ourselves.
-    const keys = hasSymbol ? Reflect.ownKeys(provided) : Object.keys(provided)
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i]
-      Object.defineProperty(
-        source,
-        key,
-        Object.getOwnPropertyDescriptor(provided, key)!
-      )
-    }
-  }
-}
-
-export function initInjections(vm: Component) {
-  const result = resolveInject(vm.$options.inject, vm)
-  if (result) {
-    toggleObserving(false)
-    Object.keys(result).forEach(key => {
-      /* istanbul ignore else */
-      if (__DEV__) {
-        defineReactive(vm, key, result[key], () => {
-          warn(
-            `Avoid mutating an injected value directly since the changes will be ` +
-              `overwritten whenever the provided component re-renders. ` +
-              `injection being mutated: "${key}"`,
-            vm
-          )
-        })
-      } else {
-        defineReactive(vm, key, result[key])
-      }
-    })
-    toggleObserving(true)
-  }
-}
-
-export function resolveInject(
-  inject: any,
-  vm: Component
-): Record<string, any> | undefined | null {
-  if (inject) {
-    // inject is :any because flow is not smart enough to figure out cached
-    const result = Object.create(null)
-    const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject)
-
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i]
-      // #6574 in case the inject object is observed...
-      if (key === '__ob__') continue
-      const provideKey = inject[key].from
-      if (provideKey in vm._provided) {
-        result[key] = vm._provided[provideKey]
-      } else if ('default' in inject[key]) {
-        const provideDefault = inject[key].default
-        result[key] = isFunction(provideDefault)
-          ? provideDefault.call(vm)
-          : provideDefault
-      } else if (__DEV__) {
-        warn(`Injection "${key as string}" not found`, vm)
-      }
-    }
-    return result
-  }
-}